~5.6 hours of the easiest LeetCode problems!

Añadido: 2026-05-05

[00:00:00]here. Let's see if this is working.

[00:00:02]Let's give this a shot. Um, so yeah, today I'm going to try to do eight hours of programming and see how far we get.

[00:00:13]Let's make sure it's working. Do eight hours of programming and see how far we get. My uh my hair is a little messy today.

[00:00:24]>> Do eight hours.

[00:00:26]>> Um, all right. So, first question is going to be counting words with a given prefix. Let's take a look.

[00:00:33]Uh, excuse me one moment. Here we go.

[00:00:36]Okay. Yeah, I think my hair is maybe a little bit. I might need a haircut.

[00:00:43]All right. Give an array of strings, words, and stringing prefix. Return the number of strings and words that contains prefix as a prefix. Prefix of strings contiguous substring best.

[00:00:55]Okay, this is a pretty straightforward one. So, we're just gonna say const auto auto check prefix.

[00:01:12]Um, I'm going to subretain this.

[00:01:18]It's going to be um prefix.

[00:01:23]This should also be by reference.

[00:01:27]Um, this should be a string and we're going to say uh for loop.

[00:01:38]So, we're going to say b check equals true return check. Actually, just return true should be it.

[00:01:50]And now we're going to say int i is zero. I is less than prefix size.

[00:01:58]Um I is less than s.

[00:02:06]I say if prefix of I is not equal to s of i return false.

[00:02:18]In this case we could write our own custom check prefix and then we can have um return stood accumulate of have a few things. It's going to be words begin words end words end zero and then this sub routine.

[00:02:47]It's going to call um check prefix with prefix and con string s and accumulate.

[00:03:10]And we're going to say return accumulate loss check prefix of fast.

[00:03:21]I think that's it. I think that's what we need.

[00:03:25]Let's see. Uh let me just check and see that the stream is working fine. How's my hair look? I think it's um see uh let me just I'm not sure. How's my hair look? I think it's um let's see uh it's a little messy. I need a haircut. Definitely need to get a haircut, but the stream is okay. Stream health. Um let me go ahead and continue with the problem. So, it looks like that was this the right way to go. Let's give it a shot. See how it goes.

[00:04:02]Let me do it on time also. I'll let that take a few minutes. Oh, it's wrong. No.

[00:04:11]Oh, that's brutal. Okay.

[00:04:16]I'll put one expected zero.

[00:04:19]Oh no.

[00:04:22]I I made an error here. There's there was a slight error here. I I knew I was taking a small risk writing this custom code. I forgot something very subtle here. It's important.

[00:04:35]Um if if this string is smaller uh yeah yeah so it's going to be pref size has to be less than or equal to s do size.

[00:04:56]That's that's what I missed.

[00:04:59]I thought I got that case but I I didn't think it all the way through.

[00:05:04]That was my mistake.

[00:05:06]Kind of I like thought I got it, but I didn't get it. Yeah, that was that was my my mistake. That's subtle.

[00:05:15]That was bad on my part. Let's submit it one more time so it feels bad. Um, o to say about that. I have no excuse. No excuse for that.

[00:05:31]I thought I got it, but I I I didn't think think hard enough about that one.

[00:05:37]Very slight slight uh thing.

[00:05:42]A square matrix mat return the sum of the matrix diagonals. Only include the sum of all the elements on the primary diagonal and all the elements in the second diagonal that are not part of the primary diagonal.

[00:05:55]Sum of the matrix diagonals.

[00:05:59]Primary diagonal, secondary diagonal.

[00:06:01]Oh, okay. That's it.

[00:06:05]All right, that's not too hard. So, some of the diagonals look pretty straightforward. It's just going to be uh int result zero. Oh, let's just double check that this fits constraints.

[00:06:22]Um, only 100 by 100. Yeah, it's going to fit an int. It's fine.

[00:06:29]Um okay so it's going to be I Z less than square to size plus I solve plus equals M of I I and then the other direction um which is almost the same thing.

[00:06:56]Um, so this one it starts off the row and the column increment in the same direction. This one you just go another direction. So um the row is still I but the column is N minus I think minus one. Double check it's minus one or not.

[00:07:21]Um where N is meant size. So it's going to be the first row but the last column which is at size minus one and then I had zero. So yeah so it should be this one I think this oh it's wrong shoot. Okay 30 25 what is uh it should be one oh but you only add oh the middle element shouldn't be added twice. Okay, now there's a slight there's a slight mistake here and that's because they're adding the middle element twice. So if uh map do size and one if it's odd then we're going to say result minus equals do size um the middle element which is like uh do size by two I think we're going to bit shift one actually it's bit shift to the one left.

[00:08:35]I think we subtract that. That's kind of subtle, too. It's a good thing I didn't submit that.

[00:08:44]Yeah, that's a subtle thing.

[00:08:48]See? Um, yep. Okay, we'll submit again so I can just double check the time in the stream health. Also, take a look at my hair again. Stream is healthy.

[00:09:00]Each time I touch my hair, I kind of maneuver it around a bit. It looks okay.

[00:09:05]So, nine minutes, two questions in nine minutes is okay.

[00:09:09]I'm trying to keep track of like how quickly I could solve these because I should be able to solve them kind of fast.

[00:09:15]That one's not a very tough one. And none of these are really that tough.

[00:09:18]This one's solved already. So, we'll just quickly explain it.

[00:09:23]Okay. Constructing the binary search tree from a pre-order traversal.

[00:09:27]Um this is a tricky one. Basically um a pre-order traversal is going to give you the the initial node then the left subree then the right subree and it recursively. So then that left subree for example is going to be the initial node the root node and then another split into left sub tree and right sub tree. So the way this would work is um in order to get the to reconstruct the binary search tree, you would have the root and then you'd have somewhere to the right is going to be the um so the first root then the left subree is going to have the the next element is going to be the root of that that node that tree and then somewhere to the right is going to be the root for the right subree. The tricky thing thing here is it's not clear um where the right subree begins. Um excuse me. So I think it's going to have to be because a binary search tree you can scope ahead basically and find where that right subree is going to be.

[00:10:46]Um, and then you and then you can create the then you can basically recurse on that that element. Um, I think it's still linear time if you do it this way even though you're doing this sort of extra these extra steps of like kind of going over to the side. The reason why I think it's fine to do that is because you're only when you move over to the right to find the next element like the next subree I think you only ever go move further to the right so like when you recurse on that right subree for example um the left subree starts immediately to the sides there's no cost constant cost there and then when you recurse again on the right subree it is you're only going to keep going to the right further. So because even though you do a significant amount of work moving to the right initially or at least when you first find that right subree overall the overall amount of work over all those sub trees is going to be at most linear at most uh so it's amortized uh linear or amortized constant basically over all those operations. So you can do that just fine. So basically you can just um root node is first node next element is the left sub tree root node recurse almost not exactly recurse but almost recurse before you recurse. Scan to the right until you find the first element that's larger than the root node. That's going to be the beginning of the uh Oh, no, excuse me. That's um yeah, that's necessarily going to be the beginning of the right subree because it's a pre-order traversal, which means that that root that element is always going to be that first element is always going to be the root root of that right subree. I think this is correct. I think you can do it this way. I could be wrong, but I think that's the way to do it. I've saw this already, so at some point in my life, I knew the answer, but we're going to we're going to skip it. I think that's the way to do it. Um but uh that's how I would do it now if I did it again. Okay. So, but that's I think the way to do that. Um I'll maybe come back maybe at some point I'll come back and and try it again. Pgram is a sentence where every letter of the English alphabet appears at least once.

[00:13:04]Sentence string containing only lowerase letters turn true to penagram false.

[00:13:10]Okay. True or false? So this is a pretty straightforward one. Um basically just use a full frequency or has uh as letter right. Um and make this empty initially uh fill this letter.

[00:13:43]Um for con charge in sentence it's also um turn in count zero. Um, actually we could even I mean just thinking how how big are these?

[00:14:14]I think we want to optimize this a little bit.

[00:14:17]A thousand. Okay, that's fine.

[00:14:20]We'll just keep it simple. So, uh, we're going to say has letter of chus a or equals with um true.

[00:14:38]I think we I think we just set it to true actually.

[00:14:42]And then um return stood accumulate of has letter six um z= 26 something like this. I think it just be equal to 20 26 is fine but something like this works I think. Let's try.

[00:15:15]Yeah, I think that's it. Let's go for Yeah, very straightforward.

[00:15:23]Just basically save uh in a like a boolean um set set of bulls like or array of BS whether or not those characters are there or not.

[00:15:39]Cells in a range on an Excel sheet.

[00:15:42]Cell row column of an Excel sheet is represented as a string. Column row interesting where column denotes column number C of the cell is represented by alphabetic letters.

[00:15:56]The first column is denoted by A second B so on. Row is the row number of the cell. So given a string s the format column one column row one column 2 row two and give me an example column row represents such that R1 R2 okay so it's going to give you like a subsection of a of a grid the list of cells such that this is true um the cell should represented as strings in the format above be sorted in non-dereasing order first by columns then by rows uh sorted in nondereasing order first by columns and then by rows.

[00:16:43]Oh, okay. Column and then row. Oh, that's interesting. It's a column, row order.

[00:16:49]It's a little bit unusual, but yeah, it's kind of somewhat inverted, but so column and then row. Okay.

[00:16:58]Usually it's row column.

[00:17:00]Um, so K1, K2, L1, L2. Okay.

[00:17:07]Column and then row. All right.

[00:17:12]Um, huh.

[00:17:20]Interesting.

[00:17:24]So, it's going to give you kind of a subsection. And then we got to do column row list.

[00:17:32]All right. Um little odd, but I think I can handle this.

[00:17:45]um can also let's just see okay it's between a and z and one and nine all right um interesting so constant row one row one or K1 or C1.

[00:18:17]It's going to be CS of zero A C2 is U I think three zero one two three yeah three uh R1 is R2 it's one and four I And this is minus zero. These are characters. So, uh yeah, second one is the row and then um third, fourth, fifth, the fifth characters, right? Okay. A little bit confusing, but um so we're just going to convert. So, we're going to say for int row equals R1. Actually, we should do column. Yeah, column column order.

[00:19:16]column C1 C2 column row R1 row is listed R2 row um and then return result and this is going to be resultserve Um, it's going to be I think the R2 - R1 * C2 - C.

[00:19:53]I think that's how many elements I need.

[00:19:55]I think that's right.

[00:19:57]And then we're going to use um so we've got to convert these strings.

[00:20:04]So result pushback um a string like it's going to be uh consistent mode maybe string I'm not really sure actually can I construct the string this I could try. Um, so um I wonder about this. I don't know.

[00:20:46]String.

[00:20:49]Let's just say next or we'll just call it s.

[00:20:56]Not really sure.

[00:21:02]I'm going to move it anyway just to see how this goes. So the column comes first and the row comes next. The column character is going to be um plus a I think I have to think about this a little bit more. And then the row is going to be plus one or I think just plus zero.

[00:21:37]It's something like this. I don't I got to think about a little bit. What's up?

[00:21:43]Hello. How old are you and what's your background and current situation in tech? Hello, sir. What's up, Nico Rocket League? Welcome. Howdy. Uh up in my 30s.

[00:21:54]Uh my background I was I worked on algorithmic trading systems for uh the corporate world. Um did like client services for buy side equities.

[00:22:06]Um and uh current situation in tech I'm currently looking at so I have a degree T8 a course in computational geometry when I was younger. Uh worked almost four years in the corporate world.

[00:22:24]Um I've been programming for like 20 years like since I was a kid. uh almost 20 years uh on it. Not working currently as a developer though because I'm kind of in a weird place in life. I I've been looking more at like doing um mentorship tutoring and or coaching um and doing some YouTube make some YouTube videos uh at the moment and yeah I work at the moment I don't work in tech explicitly at the moment I do uh um I just work in fast food at the moment which is pretty pretty easy or I shouldn't say it's easy it's It's different. It's a little easier than tech in my opinion. Runtime error out of bounds.

[00:23:18]Uh undefined behavior UB. That's a That's unusual, huh?

[00:23:25]Um index 75 conchar.

[00:23:33]What did I do here? Huh?

[00:23:36]I might need to think about how I want I don't want to use a string stream for this, but that's one way of doing it.

[00:23:44]Um, I mean, I could do it this way, too.

[00:23:46]This is probably easier. There's a few ways to do this. I think let's try this. Let's see what this does. This is This may not be the best way to do it. I'm sure there's better ways to do it. There's like Yes, there's like subtleties of string manipulation that I'm like not super familiar with.

[00:24:06]Um, yeah, there we go. Straightforward.

[00:24:09]That works. I mean, this wasn't the best solution because it was it just took a while to program. Um, it's reasonable, but it it's like not the best. All right. How we doing on uh uh what's the health of the stream?

[00:24:25]Okay. Not just buffering a little bit, I think.

[00:24:29]Okay. Let's just give it a moment to stream buffering. Also, what's the health of the stream? Okay, not just buffering a little bit, I think.

[00:24:39]Okay, let's just Okay, doing better now.

[00:24:41]All right. Um, sweet. So, yeah, I mean, that's that's an okay solution.

[00:24:47]Um, but yeah, I mean, as far as employment, like the last recruiter I spoke to, they were looking at um well, I I shouldn't get into all that. like the the roles that I apply for now. Um some of them pay like 350,000 a year and some of them pay like half a million a year. Um but I'm kind of not too excited about those rules for various reasons.

[00:25:21]Final prices with a special discount in a shop. You were given a an integer array prices where prices is the price of the item in a shop. There's a special discount for items in the shop. If you buy the i item, then you will receive a discount equivalent to price of J where J is the minimum index such that J is greater than I.

[00:25:41]And prices of J is less than equal to prices of I. Otherwise, you will not receive any discount at all. Alternative array answer of I final price you will pay for the item shop considering a special discount. Okay.

[00:25:55]Item zero price receive a discount price four minus four is four. What is the okay we get the integer array special discount i item equivalent to price j the minimum index such that j is greater than i and price j is less than price.

[00:26:20]uh otherwise there's no discount. So there's got to be some element to the right. How many elements are there in this array? This is like kind of a look ahead question.

[00:26:34]Okay, it's only 500. So I mean we could do a very basic approach.

[00:26:40]It's the first element to the right that's smaller basically.

[00:26:46]Um, I mean a look ahead's fine.

[00:26:51]I'm wondering if I should use a stack to do this. Might be easier, more efficient.

[00:26:59]A brute force solution is fine here.

[00:27:01]Like you just look ahead for each element, but a stackbased solution basically you push the element when you see it.

[00:27:12]Um, then when you push then when you see an element that's smaller, you pop everything from the stack that's larger and push the smaller element on.

[00:27:25]Yeah, that's the way to do it. Stack stack works nicely.

[00:27:31]Excuse me.

[00:27:34]Stack's pretty solid here.

[00:27:38]So vector results um reserve prices of size.

[00:27:56]Then we're going to have a for loop a stack.

[00:28:01]I'm going use a vector as a stack.

[00:28:05]Same deal.

[00:28:10]Uh then return prices.

[00:28:17]Um we're going to say just do this prices.

[00:28:29]You can actually even go further. You can do it like this.

[00:28:34]X and prices doesn't really matter. So gonna say for um st.top is greater than x pop.

[00:28:52]So st not empty.

[00:28:59]And then we're going to say the following.

[00:29:06]We're going to say result pushback st minus x right push and pop and then um t push back it's actually it's because I'm using vectors it's going to be back.

[00:29:34]Pop back.

[00:29:37]Um, yeah.

[00:29:43]And then ST push back X. Something like this, I think, is what we want.

[00:29:53]Wrong. What did I do wrong?

[00:29:57]I'll put eight. So uh we have x is the price st is empty so we skip push x which is eight onto the stack. Then we see four um and then we say okay uh the stack which has eight it's not empty has eight is greater than four we're going to push on the result we're going to push 8 minus 4 so we should have pushed 8 minus 4 oh I returned prices that's why excuse me should return salt.

[00:30:46]That's okay. I was like, where is my logic ring gear? What did I do? Oh, it's wrong there.

[00:30:52]Okay. Uh 442 should have been.

[00:30:59]So, push the four, we pop eight, then we push four onto the stack.

[00:31:04]Oh, I see the issue. Then we put six onto the stack, I think.

[00:31:10]Um, oh, you know what? It might be.

[00:31:19]It maybe should be a Q actually, not a stack.

[00:31:26]Yeah, I think I'm supposed to push four minus two before I push.

[00:31:33]If I do it this way, I'll have I'll push four and two, not two and four. It'll be the wrong the wrong sequence but also it's um I see what I'm missing here. Okay, that's subtle. So for um empty uh Can't I did it slightly slightly incorrectly and just I think I need to dump the rest of the elements in there. So I do need to use more like a Q than a stack.

[00:32:21]Yeah, these are these are going to be in the wrong wrong orders.

[00:32:25]Okay. Um Okay. Interesting.

[00:32:30]So, what's interesting about this is that um I don't think I need to use a Q necessarily because this is going to always be a a max.

[00:32:46]Um Oh, no, no, no, no. It's it's it's correct. It's just I just need to reverse this, that's all.

[00:33:00]It's a bit awkward.

[00:33:05]Yeah, it's a little awkward.

[00:33:07]We're going to do it like this. This is a little awkward, but I think this is right.

[00:33:15]Yeah.

[00:33:20]Okay. So, we're going to do the following.

[00:33:24]Um, and then and then we dump this into the result.

[00:33:46]Um, it's actually going to be more like this.

[00:34:08]Yeah, it's a little awkward. It's a little awkward.

[00:34:27]something like let me see what was this wrong. Okay, hold on.

[00:34:41]Okay. Yeah. Yeah. So, I got I did re I did do this middle part correctly, but the last part's just slightly incorrect.

[00:34:48]Um, just did the same thing as this here.

[00:35:00]Um, just Let's see.

[00:35:17]Okay.

[00:35:19]Still wrong.

[00:35:26]Uh oh. These are not supposed to be reversed.

[00:35:34]Is that it?

[00:35:38]Okay. a little bit better.

[00:35:40]There's something wrong here. Um.

[00:35:49]Oh, I think they Oh, the Oh, less than I'm sorry. That's my mistake. Um, I'm sorry, but I shouldn't say I've been saying I'm sorry a lot lately because I have co-workers that are very Oh, I shouldn't say that either. I shouldn't say that either.

[00:36:09]I've been working lately and I apologize a lot to my co-workers because uh I don't know what else to say quite frankly.

[00:36:19]I don't know what to say. I don't want to upset my co-workers. So, I just apologize constantly.

[00:36:25]Uh is this easier to do it that way? I think I don't know if it's easier to do that way. I have no idea. This seems to be correct, but I'm not sure if this is the best way to do this.

[00:36:34]It's wrong. It's not correct either. Of course not.

[00:36:40]>> Uh I might be trying a little too hard on this one. The the the approach I described earlier would be sufficient for the time balance and I probably should just use that one, but part of me feels like I should try to do something a little more sophisticated here. I'm surprised this is wrong.

[00:37:13]What happened here? Uh, okay. So, I had the one here.

[00:37:20]94.

[00:37:25]Um, you know what? There is actually a better way to do this. There's This is just wrong, I think. Hold on. Let's go back back to the drawing board here.

[00:37:43]Actually, I had the right idea the first time around. I just didn't think it all the way through.

[00:37:49]So, I did actually, not that I did it correctly the first time, but I was close the first time. Uh, I I think I know I'm doing it wrong here.

[00:38:04]So, what it's supposed to be is the indices, I think, in this stack.

[00:38:12]Um, so I do need to do Yeah. Okay, let me do it this way.

[00:38:24]Um, in this case we can do something like the following.

[00:38:40]All right. Uh, stack empty stack back. So it's going to be still going to have a stack but it's be a stack of indices.

[00:38:49]So it's going to be prices stack back and then we're going to not push back but we're going to write to the index result of ST back is going to be equal to prices.

[00:39:09]Yeah, this I think is what I was supposed to do initially. I just kind of didn't think it all the way through, I guess. And then then we push X back on back of the stack. Yeah, I think this is what I'm supposed to do. Supposed to be index based. Um, and then I just write the indices at the end. So, um, yeah, that's just going to be push back, not push back, but result of the index the pointer.

[00:39:41]And then we do prices of it's just going to write basically this something like this.

[00:39:50]Let's see.

[00:39:54]Um oh and x is uh price of y.

[00:40:02]I could just do constant x.

[00:40:07]Um, yeah, I think I I kind of goofed this. I kind of Yeah, I kind of goofed this. Okay.

[00:40:18]Buffer overflow. Okay.

[00:40:22]Of course. Um.

[00:40:29]Oh, no. No. Push X. Whoops. Push I. That That'll do it. Yeah, that'll cause buffer overflow.

[00:40:37]All right, there we go. That's correct.

[00:40:40]Yeah. Um, I goofed, man. I goofed.

[00:40:46]I don't know what to say. I should have I should have thought that through a little bit more from the beginning. Um, it's more of index based kind of thing.

[00:40:56]Uh, yeah. I don't know, man. No excuses for that.

[00:41:02]No excuses for that.

[00:41:06]That's uh there's other there's a few other problems that are similar to that, but yeah, that's a linear time solution rather than a uh a uh I don't know.

[00:41:14]Yeah, no excuses. No excuses.

[00:41:18]Um find elements in a contaminated binary tree. So, I've already solved this one. What are some of the uh things to say about this?

[00:41:27]It's also linear time memory also that previous one binary true the following rules root.v val for any tree node. If tree nodev val is value x and tree node left is not equal to null and then tree node.v valals 2 * x + 1. Okay, true. Val has a value x.right is not equal to null. It's 2 * x + 2.

[00:41:53]Okay, so it starts off with zero. If it has a node on the left, it's going to be twice that plus one. So it's going to be one. Then the one on the right is going to be two. Then the one if we repeat that times two is two + one is three on the right of that is so it's going to be zero one two three four five six and so on. So it's kind of like a um if it was a full tree it would be uh like a level order uh traversal of like the natural numbers.

[00:42:31]um or yeah level order kind of a I don't know what the word is for that um placement of the natural order of the natural numbers starting from zero rather than the natural numbers the posit non negative integers non- negative integers so integers including natural numbers including zero now the binary tree is contaminated which means all tree nodev val has been changed to negative one no what implement the find elements class find elements ments. Initialize the object with a contaminated binary tree and recovers it. Find target returns true.

[00:43:05]The target value exists in recovered binary tree. Oh boy.

[00:43:11]Uh oh. Um okay. Interesting.

[00:43:22]So So I've got to recover.

[00:43:28]Huh.

[00:43:31]and then have the find routine.

[00:43:35]Interesting.

[00:43:38]Well, the find each of the finds can be done in binary uh logarithmic time logarithmic and the I think the not exactly logarithmic. I'm not really sure actually the find is a little bit complex.

[00:43:57]Um total number of nodes is 10,000. Total number of calls defined is 10,000.

[00:44:05]Height of the binary tree is less than equal to 20. Okay. Well, if it's the height is less than 20, then yeah, you can do the find can be linear in the height.

[00:44:16]But yeah, the it should be linear in the height. The basic approach.

[00:44:23]See, like I said, I've already solved this one, so I'm not going to solve it again, but I'll just give a brief description of how you could solve this.

[00:44:29]So, I would say I'm not sure it's really necessary to um actually modify the tree. I don't know.

[00:44:40]I'm not sure if they're if the way they program this is actually going to check that. Um, null, true, false, false, true.

[00:44:56]I don't know. I don't know if they even if they don't bother to check whether or not I mean the tree it's not that hard to recover the tree. It's I mean you could just do the whole thing. I guess it's fine. Um so you would you would literally just recurse from the uh simple recursion is fine and in order traversal is fine. So you would say or you could do pre-order is fine too. So you would set the root node to zero and then the left side and the right side.

[00:45:25]Um you would uh you would just save the so in the recursion you just have an integer that that you parameter that you save like what the next value is going to be. So starting from zero you have you know 2 * 0 + 1 and then the other one will be 2 * 0 + 2 and so on and so you can recurse that way. So yeah pre-order traversal works fine.

[00:45:49]um recursive approach and then that's if you had to write the new val the correct values to the tree and obviously if it's a null you just skip it um if the tree denotes null um and then the find you would just run on the tree um you know left or right depending on what you're searching for. So, uh whether or not the value is going to be in the left subree or the right subree is it's actually not that obvious where it's going to be. Um I have to think about that actually.

[00:46:34]What does the find routine look like? Uh it's going to be let's see if you defined five. Let's do something more complicated like let's say you defined like um it says 10,000 nodes. Let's say you defined like 5,000. So, start off with zero.

[00:47:05]5,000.

[00:47:07]Um, that's actually a good question. How do you would you go to the left subry or the right subry for 5,000?

[00:47:22]Um, good question.

[00:47:33]Well, you have two options, right? You have either um subtract one and divide by two or subtract two and divide by two.

[00:47:43]If it's even, 5,000 is even. If you subtract one and divide by two, you're going to get a uh an odd node.

[00:47:57]That's 49 4,999, which divide by two gives you 2,450 plus half of 98 or 99, which is 48.

[00:48:16]I think they both give you 2,998.

[00:48:22]No, not 29. No, 2,498.

[00:48:27]2498.

[00:48:29]24,499.

[00:48:33]Uh, let me think about that a little bit more.

[00:48:43]5,000 - 1 4,999.

[00:48:46]Divide that by 2. The 4,000 becomes 2,000. The 900 becomes 450. The 90 becomes 45.

[00:48:54]So you get 2,495.

[00:48:58]And the 9 becomes four.

[00:49:01]2,499.

[00:49:05]I think it's in both cases.

[00:49:09]Yeah. So, actually in both cases you get 2,499 if it's odd, if it's even. If it's odd, um let's say it's 5,01, subtract one divide by two, you get 22,500.

[00:49:23]If you subtract two and divide by two though, you're going to get not 2500, you're going to get um 2,499 again.

[00:49:32]So, there is a different meaningful difference there. Uh, I'm not sure which one to expect.

[00:49:43]Um, well, for sure if you divide by two, if you subtract by this one or two and divide by two, you're always going to get a whole integer because that's how these are generated, right? So it's clear then if it's odd you would you would do subtract one divide by two it's even you subtract two and divide by two and then you recurse several times until you get to the root node. Um yeah and then and then so you recurse several times or repeat several times till you get to the root node and then just reverse that process back down.

[00:50:37]And if that if you have those nodes all the way through, then your find routine works. If not, then um you return false because you hit you'd hit some node where you're not you're not going to get the path the correct path to the value.

[00:50:55]I think that's the way to do this.

[00:50:57]That actually is substantially more complex than I thought it was going to be, but that should work. I think that's correct.

[00:51:05]But yeah, that's that's a that's a more complex one, I guess. Um, let me see the chat is getting here. What's up, chat?

[00:51:15]Hey, Pro guy. Welcome. How's it going, code guy? Hope everybody's going well.

[00:51:18]Why don't you teach these topics on your channel? I would love to hear from a smart person in the community. I appreciate that. Thank you. Um, I should do that. I think that's a good call.

[00:51:25]Your lead code ID, I want to follow you.

[00:51:27]Subscribe. What's up? Well, welcome Devkin.

[00:51:30]Devkin uh and unsharma.

[00:51:35]Devk canand An unsharma.

[00:51:39]I I appreciate that. Um okay, let me uh let me show you. Let me show you. So here here's my here's my Whoops. Um it's my lead code. Whoops.

[00:51:58]There we are. Um, yeah, I've solved a few. I have a lot more to go, though.

[00:52:04]Got a lot more to go. But I appreciate you. I appreciate the support.

[00:52:07]Appreciate that. Um, yeah. So, I think that's going to be the way to solve this one. I think that's going to be the way to solve this one.

[00:52:15]Um, we'll go to the next one, though.

[00:52:18]I'm not going to code it because I already already solved it. But this one I solved, too. Okay, I'll explain this one, too. Sorting the sentence. Uh a sentence is a list of words that are separated by a single space with no leading or trailing spaces. Each word consists of lowerase and uppercase English letters. Sentence can be shuffled by appending the one indexed word position to each word then rearranging the words in the sentence.

[00:52:42]Okay. Um I have to think about that. For example, the sentence this is a sentence can be shuffled as sentence for A3 is to this one or is to sentence for this one A3.

[00:53:00]Okay. Oh, the one index word position to each word and then rearranging the words in the sentence. Okay. So that's the shuffle. Okay. So you append the one indexed position to each word and then you and then you swap them around and permute the words. Okay, got it. Given a shuffled sentence containing no more than nine words, reconstruct the original sentence. Okay, so the trick here, the key here, excuse me, is to get split each each word on the um single white space, right? and then um figure out the index of that word from the last character, excuse me, of each of those strings and then rewrite recreate construct the string uh with those words in the correct spot.

[00:53:52]So that's a really interesting I like this. This is a good question. I like this one. I've saw this one already, so I won't won't go through it again, but that's the basic premise basic approach.

[00:54:02]And I think there's an easy way to do this in C++ using um uh you can use string find I want to say to find the space and then you can use the sub a string substring to get the word that's at at that string at this point. Um, and then you could write those into a um I think it's at most nine words. You could write those into a um a vector of words of strings. A vector of strings. You write each string into the vector of strings. Um, and then also save like an array of ind of integers that at the index of the string, you also have the index of that integer array which has the where which has like where it's going to go. And then you can read both off simultaneously and reconstruct the the string by just um concatenating. So um yeah uh well or you could see not the best way to do it. Um, I like I would I want to concatenate at the end, but I would say take the ah I got it. sort sort the um the array of strings that I've just created. Sort it using the array of positions.

[00:56:20]Um and then concatenate then concatenate straight across. That's probably the easiest way to do it.

[00:56:26]I like that approach. That's probably Yeah, I think that's a little bit easier because if if you make it a little more complex than that, then I think it uh gets a bit awkward.

[00:56:38]Yeah, I think that works. Okay, I was going to say actually you could even do better than that. Instead of creating a um a second array of integers that keeps track of like what these values are, you can just dump the you can you can split the strings into these segments as mentioned and you'll get a like a vector of strings and then you can sort that vector of strings itself based off of the last character of each string.

[00:57:08]That's might be a better way of doing it, easier way of doing it. And then and then when you read off you just you just exclude you just substring each each string excluding the last charact or you just you just pop the last character when you concatenate you can since you're creating this vector of strings anyway and I guess you could use a string view to keep make things a little bit easier if in C++ to be a little more optimized. Um but uh yeah that might be a little bit better actually to to reproduce this. Yeah, it's pretty interesting question. I like that one.

[00:57:42]It's a it's a peculiar one. Basically taking a permutation and reconstructing the original. Um it's a cool cool idea. All right, let's go to the next one.

[00:57:56]Um image message retract. What's up ECB?

[00:58:00]Welcome. Hello.

[00:58:04]All right. Oh, I saw this one too. Um find first palendroic string in the array. Given an array of strings words, find return the first palendroic string in the array. There's if there's no such string, return empty string strings palendrome if it reads the same forward and backward. Okay.

[00:58:20]Okay. This isn't too hard. A couple things to say. So this is an array of strings. It's a little bit easier. But if it was just the first palendrome in the string, there's an algorithm for palendromes. It's pretty um comes up from time to time with palendroic questions called moniker's algorithm. So this would be monitors algorithm and when you're doing palendromes it's usually relevant. Um so efficient method for finding the longest palmic substring in a given string linear time introduced by Gladen K moniker in 1975. So this is they figured this out like 50 years ago more than 50 years ago. It's been known for over 50 years, which is pretty long time. Uh, but yeah, so there's an explanation.

[00:59:12]Um, but I'm not going to explain it.

[00:59:15]It's uh it's an interesting thing. It's um basically it's it's one of those algorithms that uh it's sort of a sliding window algorithm, I guess, if I had to summarize it. And um you it doesn't just find the the all the palendromes in the string. It finds uh like all of like at each index it'll find the size of a palendrome. I think it it's I think it's you could design it in a way where it will find the like to the right how many characters to the right of that position are going to match the characters to the left like how far that goes. sort of like a almost like an onion shell kind of a thing.

[01:00:02]Something like that. Um I don't remember exactly Moniker's algorithm. I don't have it memorized but I kind of have it sort of me like I partially remember it.

[01:00:13]But uh yeah that's moniker is comes up a lot. In this case though we don't need monikers. Um in this case we just check directly um if each string is a palendrome. So the way easiest way to do that is if it's an um even or odd uh the e really the easiest way to check if a string is palendroic is exactly what they described here. Just reverse the string and check it against itself.

[01:00:40]So if if the string is equal to itself reversed then that's probably the most straightforward way to do it. But another way to do it is to just if it's odd, um, start the character on the left side, go left to right, and match that against the characters right to left until you've matched all the characters.

[01:00:58]If it's even, then you would start sort of at the midpoint on the left side and match left to right with right to left.

[01:01:06]Slightly more efficient than just copying the string and reversing it and and checking it directly, but um, it's not that much. It's not efficient enough where you would avoid that. Like in in an interview, you probably would just do the reversal because it's just way faster to program.

[01:01:24]Um, but yeah, in this case, it's very straightforward. So, I'm not going to program that one because we've already solved it. But, um, that one's on the easier side for sure.

[01:01:34]Um, hi. Hi. What's up? Uh, HG Suresh.

[01:01:38]Oh, hello. Hello. Welcome. Howdy.

[01:01:41]Everyday is going well. Welcome, welcome, welcome. We solved this one, too. Solved a bunch of these already, huh? Reverse words in a string three.

[01:01:49]Given a string s, reverse the order of characters in each word within a sentence while still prever preserving whites space initial word order. So, the way this one works, um, you would I think I did this in Python probably. I don't know if I did this in C++. I probably did in Python. Um, let me see how long do I solve this. I saw this in 2019 in Python. So actually we'll do the C++ version. So this is basically a um what you do is you split into words.

[01:02:19]Uh you no you I think you reverse the whole string split into um it's like a reverse split reversed kind of thing. I'm trying to remember exactly how this works. So uh yeah, if you reverse the whole thing, then split and then reverse each word.

[01:02:52]No, that'll reverse the word order, not the character order. We want the characters. So this you would split into words, reverse individual words and then join.

[01:03:06]Yeah, that works.

[01:03:11]Um, let's see. Uh, okay. There's seizing space. So we we'll program this in C++.

[01:03:21]This is too too bad. This isn't too bad.

[01:03:26]Oops.

[01:03:32]All right. So, let's try this result.

[01:03:39]Um, we're going to say, so we want to do s.find. It's going to be a single space.

[01:03:50]That kind of makes things a little bit easier.

[01:03:52]And we're going to say position and we're going to say position if so position equals s.find find is not equal to or actually yeah it's more like this is not equal to um state stood string end position and then we say I want to say we increment the position something like this. Um, and then we're going to say const, no, not a const. It's going to be stood string.

[01:04:42]Uh, temp is going to be s substring.

[01:04:48]Come back to that in a moment. We're going to reverse the temp.

[01:04:54]Um, and then we're going to append the results.

[01:05:00]All right. Um position is going to start off at zero.

[01:05:07]We're going to find this next position.

[01:05:13]I think I have a previous to previous position zero as well.

[01:05:19]zero position zero um previous equals position and it's going to be position + one I think something like this got to think about this a little bit um so and then we actually just add at the at the end here.

[01:05:51]These might might want these to be up here.

[01:05:56]Um, just got to run this one more time, I think, because this is going to end.

[01:06:07]Oops.

[01:06:08]Explain a minute why I got it one more time here.

[01:06:13]could do it one more time because this is going to uh this is going to exit when the basically it's going to miss the last word if I don't if I am not careful here and the substring is going to be previous to the number of characters something like this where it's the previous position the number of characters is going to be the position of this minus minus the previous position. So like if you have ABC in a space, it's going to be 0 1 2 3. Three is the position we get. 3 - 0 is the number.

[01:06:55]Yeah, I think it's pre position minus previous is the substring number of characters.

[01:07:00]Um, and then we would say plus a space.

[01:07:14]Um, same thing here. Previous and this one you don't get a space.

[01:07:25]Something like this. There can be some off by one errors or something going on here.

[01:07:31]Let's see.

[01:07:35]TLE. Okay. Not what I would want.

[01:07:40]Um, okay.

[01:07:43]Oh, I know why. Um, find from position.

[01:07:47]I think that's part of what I'm missing here. There are a lot of pieces to this, a lot of elements. Let's see. What did I get?

[01:07:57]Uh, okay.

[01:08:02]Okay. It's close but not quite right.

[01:08:05]Um, why did it go in the reverse direction?

[01:08:10]Um, wouldn't this wouldn't this take lets first?

[01:08:24]Why did it Wait, what?

[01:08:39]Temp substring previous position temp result plus equals temp.

[01:08:49]Huh?

[01:08:54]Why did uh Huh?

[01:09:02]Wait a second. What is going on here?

[01:09:10]Oh, I must misunderstood something here.

[01:09:25]Huh?

[01:09:28]What am I missing? Missing here?

[01:09:33]Where's my uh Oh, wait a minute. What?

[01:09:40]Oh.

[01:09:49]Uhhuh.

[01:09:54]Huh.

[01:10:01]Oh, that's interesting. This this debug code isn't running.

[01:10:08]Uhhuh.

[01:10:09]Okay. I must have an error somewhere that I don't realize. Okay. Um, syntactical error somewhere.

[01:10:18]Okay. Uh estind position space.

[01:10:34]Let's look that one up. Um, it might be it might be better to do CP for reference. Perfect.

[01:11:05]Yeah, this might be better. Let's do uh somewhere here. Strings.

[01:11:11]This is I I tend to struggle a little bit with string manipulation because uh it's a bit complex in C++ and I tend to um so you guys can see what I'm looking at.

[01:11:31]And I tend to um make very slight mistakes. I think I you could argue I just need a little more practice basically.

[01:11:43]Where are the Here we go. That's what I'm looking for.

[01:11:49]Um search.

[01:12:01]Oh, wait. No.

[01:12:17]Where's the find? There we go.

[01:12:21]Okay.

[01:12:24]Uh position comes after. Okay, that might be the issue.

[01:12:29]Oops.

[01:12:36]Where's the uh the uh position comes after? Okay.

[01:12:43]Count character position count number two.

[01:12:49]What's that? Find the first substring equal to the range s+ count. This range may contain null characters. If SS plus count is not a valid range, the bet is unfin.

[01:13:08]What does that mean?

[01:13:16]What does that mean? S+ count in the range.

[01:13:28]First substring equal to the range ss plus count range may contain null characters.

[01:13:38]I'm very confused by this. I don't know what can they give me example of this one.

[01:13:48]Character string to search for count length of the substring. Oh, okay. I see.

[01:13:54]I see. So, this just bounds the length of Okay, that's interesting.

[01:13:58]Um, but yeah, I think the Yeah, I made this mistake before.

[01:14:03]That must be what's going wrong.

[01:14:07]That's why the debug's not printing.

[01:14:11]There we go. Okay. I was like I was so confused. I was like, what did I do wrong here?

[01:14:18]Yeah, the string manipulation can be a little more complex because of the um the extra sub routines involved and the syntax you kind of have to remember the correct syntax.

[01:14:33]Okay, there there we go. So that's how you do that in C++.

[01:14:37]Uh also I didn't really cover how you might do this if there was more than just a single white space.

[01:14:45]Um like if there was more white space than just single spaces. That's a little more complex, but there are ways to do that, too.

[01:14:55]Probably if you had more white space than just a single space. I think what I'd end up doing is uh I do something very similar to this find routine. But more likely what I'd do is I would alternate between searching for things that are not whites space as like a chunk of text and then searching for a chunk of text that is whites space and probably um I'd have to think about how exactly I'd want to handle that. Um, but I would likely take the chunk of text that's not whites space, reverse it, append it to my result, take the chunk of text that is whites space, not reverse it, append it, and then keep repeating that way. Um, something like that. Uh, but yeah, I would have to alternate each search procedure, toggle the search procedure.

[01:15:51]Um, so it'd be a little more complicated programming that um the loop conditions would be different. I think I might have like a toggle like there's a way to toggle your loop conditions which is peculiar but yeah you just I've done that before. I've had I've had toggling for loop conditions. It's definitely very peculiar thing but you can do it.

[01:16:16]I've done it before.

[01:16:19]Um, all right. Let's see what uh what else here. Um, maybe keep this open in case I do more streaming stuff. Let me I need to actually charge my computer. Let me uh me check the stream health and then maybe I'll charge the computer. It's been like an hour, which is good. Stream is healthy.

[01:16:39]Um, let's grab another question and then I'm going to go ahead and um grab another question and then go ahead and plug in my computer while I'm thinking about this question.

[01:16:54]Sum of all oddlength subarrays. Given array of positive integers as array, return the sum of all possible oddlength.

[01:17:06]There's my subarrays of ribs. Uh, interesting.

[01:17:13]The oddlength subarrays. Well, that's peculiar. Uh, can you do this in linear? Yeah, I was going to say there's probably is a way to do this in linear time.

[01:17:28]Gulp. Um this so the sum of all subarrays can be done pretty efficiently I think by um excuse me think about the sum of every subarray.

[01:17:54]The sum of every subarray would be like adding each. So the the subarrays of size one, you'd add each element once.

[01:18:04]Subarrays of size two, you'd add each element twice except the first and last element.

[01:18:12]Um I think that's correct because there would be overlap summary for size three would be every element once twice three times across then twice and once again is the pattern.

[01:18:36]Um, and then if you add these things all together, you have ones across, one, two's across, one, one across, two across, 1 2 3 across, 3 2 1. You add them all up, you end up with like three + 1 + 2 + 3 um 1 plus 1 plus 1 1 plus 2 plus 3 or yeah 1 plus 1 plus 1 1 plus 2 plus 2 1 plus 2 plus 3.

[01:19:12]Uh interesting.

[01:19:20]So like each element would end up being added like you could you could calculate that. I think you could figure that out.

[01:19:26]How many times does each individual element get added if you added every sub all the subarray sums of all the subarrays together?

[01:19:39]Excuse me. I think it's going to be for the first element and the last element it's just the size of the array n * 1 I think uh well I would say if it's a size four you do one size one size two size three and size four yeah before the n times the first element then the second element is n minus one * 2 + 1.

[01:20:13]Then next elements n - 2 * 3 + 2 * + 1. And so it's going to be n - i * the index time x or yeah n minus yeah uh n - i * the index plus the sum from one to i.

[01:20:40]uh yeah from 1 to i which is going to be I think i * i + 1 / 2 um and then that whole quantity. So n - i * i plus i * i + 1 / 2 that whole thing times the element and take that over the sum sum over the over all the elements.

[01:21:09]I think that's the solution for uh just the sum of all the subarrays and then the sum of all the oddlength subarrays.

[01:21:16]Basically, you're going to cut that down. Um somewhere in there you modify, excuse me, modify those values. So I think the i * i + 1 /2 term probably becomes more like uh i^2 because you're just you're just not adding the even values in between probably something like i^2 over maybe over two have to think about that a little bit more. And then for the even values, oh excuse me, not the even values for the other portion um where it like gets capped I guess.

[01:22:05]Uh I think it just divide by two. So instead of instead of being n minus i times i, it's like n minus i * i / 2.

[01:22:15]It's something like that. But yeah, I'm pretty sure this can be done in linear time. Just need a little bit of um I guess manipulation.

[01:22:23]All right, let me go ahead and um let me go ahead and plug my computer in and then I'll come back. One second.

[01:23:19]Okay.

[01:23:21]All right. Um, give me one second here. Uh, all right. Back. So um let's try to do it in linear time. So as I mentioned, let's say it's going to be something like the following.

[01:23:52]Uh I want to say this is a good question.

[01:24:12]actually let's do it this way. The number of times this particular element gets added.

[01:24:20]All right. Um, if the array is of length 1 2 3 4 5, we're adding one once for the size one, one once for size three, and one once for size five. So five, three, and one.

[01:24:39]It's three times.

[01:24:41]So it would be like 5 - 1 / 2 + 1 I'm going to use N to hopefully simplify things a bit.

[01:25:01]Whereas if it was just um I is zero, right? The first element, it would be N minus I is five. But in this case, it's it's half of that plus one.

[01:25:20]if it was even so six.

[01:25:23]So I can I think yeah you subtract one divid by two and add one. I'm not sure I'm if it's six you would do one three and five again. It' still be just be divided by two.

[01:25:38]So if it's even you divide by two. If it's odd you divide by two and add one.

[01:25:55]Interesting.

[01:25:59]And just think about that for a minute.

[01:26:06]Do you add one? Ah, there we go. Add one first and then divide by two. That's easier.

[01:26:12]Okay.

[01:26:15]Add one first then divide by two. So five becomes six divide by two get three. Six becomes seven divide by two is still three. Okay.

[01:26:26]All right. Um now how is that related to I however well let's say we shift over to I I is one how many times does four show up in the odd length subarrays?

[01:26:51]Um oh yeah this was this was yeah one three and five right. So, this one's going to be also 1, three, and five, but it shows up twice in the three and twice in the five.

[01:27:11]Um, yeah.

[01:27:31]Let's do let's do it like this.

[01:27:36]Let's do um it's like the first count and the second cow.

[01:27:50]There two two parts to this.

[01:27:55]This is going to be the like flat count and this is going to be the rising count.

[01:28:08]I'm not really sure what to call those two things.

[01:28:14]So, I'll call them these things. Call them this um So this expression minus I okay that may or may not be correct. I'm not sure about this. This actually this might be a minus I here or something. I'm not sure where this minus I fits in. I think about it. So for four I plus two is correct. It's twice um 1, three and yeah. Yeah. um in each of the subarray lengths that are three and five and so on. The ones that are greater than or equal to two, it's going to show up twice.

[01:29:17]Each of those it shows up in the three length.

[01:29:29]Three once, twice. It shows up in the five length once.

[01:29:45]There's a rising. is a falling in a in a flat amount.

[01:29:59]If this were if it were not odd length, it would be once for one, twice for two, three times for three.

[01:30:15]Well, not three times for three.

[01:30:18]Like the two is three times for three, but four is not three times for three.

[01:30:27]Oh, that's confusing, huh?

[01:30:49]Once for one, twice for two, twice for three, and only once I think twice for four, and only once for five.

[01:31:08]Okay.

[01:31:15]The reason why it's only twice is because um it's going to be the minimum.

[01:31:23]It's because it's it's it's uh like locked on the side. I'm not sure how to express that.

[01:31:31]it's because it it it's too close to the side. So even though you have these larger arrays, um they aren't going to reach this number more than two ways.

[01:31:48]Oh boy.

[01:31:53]So actually this flat part is a little more complex than I thought initially. Um it would actually be you'd actually subtract two of each I value.

[01:32:13]So it only appear three times as four times two.

[01:32:22]Um I think this basically this is doubled.

[01:32:27]That's what I'm saying.

[01:32:34]Um that's in that's if you just added all of the subarrays. But if you just added uh the oddlength subarrays, I think it' be three.

[01:33:18]I think if I took n minus i, let's do it like this.

[01:33:31]Um, the amount's going to be two for sure, but in this case, it would also be a two. Like for five, uh, five and four mirror each other.

[01:33:56]um constant. I'm not sure what to call this. Like let's just say bound.

[01:34:04]It's going to be the smaller of these. I + 1 and n minus i.

[01:34:14]So if i is one, it's going to be the bound between it's going to be bounded by two. But if also I is 0 1 2 3 there's going to be n minus i which is five basically the indices on the other side.

[01:34:39]So one and one 0 1 2 3 4 um smaller of these two.

[01:34:50]So one and four plus one and then when you see four it's going to be one plus one is two. It's gonna be this bound and then so the flap flap count count is going to be multiplied by this bound.

[01:35:04]And then also um that bound I guess defines how many of these other values are not included. um for that bone. So like at i equals 1, we're going to have these three. At i equals 2, it's just this middle element.

[01:35:32]Uh and the other ones are going to be sort of rising values. Um so let me think about this.

[01:35:53]Um, it's not I + one by the way. It's it's this bound. But what I'm multiplying by the bound is I want to say N minus bound.

[01:36:17]Again, this is for if it's not odd length. Odd length is a little more complex, but let's just suppose it was not odd length.

[01:36:24]Um, in this case it would be 5 - 2 is three of these.

[01:36:35]Um, and then when I is 2, 5 - 3, that's not quite correct because this basically doubles at each iteration.

[01:36:51]What's being removed?

[01:36:54]Um their correct way to understand that would be like um it be sort of like bound minus one bit shifted to the right.

[01:37:25]This I think is the correct flat count for non oddlength. So from i for i is zero.

[01:37:34]Um the whole thing is a flat count which gives you bound is one um n minus 0 * 1 is n.

[01:37:51]So that's what you would get for the first element. The number of times that shows up, it's five times which is correct. The rising cow would be zero there. For I is one.

[01:38:03]Um I get this bound of two. 2 * 2 - 1 is one. Bit shift to the left is two. So we get one two of these excluded. three * 4 uh three times you would get two which is correct. It's going to be the one case, the two case, we get two. The one case gets excluded. Two case, the three case does this twice. The fourth case does this twice. And the fifth case also gets excluded.

[01:38:34]So I think that's correct for the flat count. And then the rising count is going to be um we're going to do the it's basically n.

[01:38:46]Um, so whatever the bound is a temp variable.

[01:39:00]This might be easier.

[01:39:12]Um, so this rising count is a little bit more complex.

[01:39:26]Um, it's going to be the sum. So like if you're looking at two, it would be one plus two and then this one has a three.

[01:39:36]Uh, and it's 1 plus two on the other side, too. So you'd multiply by two which is I already have that here. This this rising count times two.

[01:39:47]Um this 1 plus two comes from I said I think we said the bound was two actually I think yeah yeah. So here here the bound would be three and we're going to have the sum from one to two not up to three. So we subtract one to two. So it's going to be the sum from one to two. Sum from one to two is going to be uh that value times itself plus one divided by two. So 2 * 3id 2 is three. Yeah.

[01:40:23]Yeah. That that so this works for the um sum of all the subarrays.

[01:40:33]But for the oddlength ones, things get more complex. So, those of you who have been following me so far through this, I appreciate that. This is definitely one of the more complicated. Um, if I just run this, I won't get the right answer, but I'll get uh I can at least verify that my thinking is correct here. So, I got 110 for this one.

[01:41:00]So we get this sum five 6 7 12 15.

[01:41:08]I don't know if I want to do all that by hand. That might take too long. Let me not try to verify that all by hand.

[01:41:15]That'll take a while. Um the next thing is all right. How do I modify this for the odd counts?

[01:41:23]Uh the odd odd length arrays.

[01:41:28]I wonder if I just divide by two. That'd be kind of funny if it was that simple.

[01:41:34]It almost looks like that. No, it's not.

[01:41:36]Okay. I was gonna say if we could just divide by two. It' be nice.

[01:41:41]It's close though.

[01:41:44]Um let's see. Did it work in this case?

[01:41:47]110.

[01:41:50]Uh add these three. Add these two. Add these two. And then add each each three again.

[01:41:58]So that would be 21 + 12 is 33.

[01:42:04]33 twice is 66. And then add 76 uh + 12 is 88 and then plus 22. Yeah, I did get that did calculate that correctly. Um let's see about uh okay in the odd case now how does this change? Well the flat count is going to be um let's think about this again.

[01:42:41]So, we're still going to do like let's say in the second case, it's still going to be a one, but we're not going to have the two in there um for the rising count.

[01:42:54]So, the rising count is still going to count one, but we're not going to have it's not Oh, no. I'm sorry. Let's do Let's do the case. Let's do the middle one. Let's do three. It's a little bit easier to think about three. So for the rising count, um it's going to appear once in one and it appears once in and three.

[01:43:12]So we do still get 1 + 2 there.

[01:43:18]Um actually no, maybe it's better to try four. I feel like I need more elements to really understand this. Um, that's confusing. That's very confusing.

[01:43:36]It's very confusing.

[01:43:39]Uh, let's let's do four and then two.

[01:43:42]Let's just do them separately and see see where it goes. So um in this case we do add one one time for the one case and we don't add two for the two case and we don't add two for the three case either. We do add two for the three case though.

[01:44:11]Um do we add and we add one for the five case. So it becomes one two one instead of one two two one two two one becomes one two one.

[01:44:26]Okay. So we lost two elements from the flat count. Basically um this section this part basically was divided by two instead of three multiplying by three we multiply by one and I think that's basically it actually just uh you just take this whole thing add one and divide by I think that's it.

[01:45:06]So save account modifier.

[01:45:29]Um, yeah, I can just add one. Add one and divide by two, right? Because it went from from three down to one.

[01:45:50]Actually, no. I don't think he even I don't think he even had one.

[01:45:56]I think you just straight up divide by two.

[01:45:59]Yeah, three would go down to one. What is four? Four probably goes down to two.

[01:46:05]Um, this doesn't have a four.

[01:46:12]Yeah, it doesn't have a four. Um if you had a sixth element here then it would be at four here for the parts that would be counted um twice to be four times.

[01:46:28]Um, in that case, what did I say? You just I was saying that it would be it'll only be twice. So, if there were six elements, you do two times would show up twice.

[01:46:53]Three. No. No. Yeah. But that gets discounted. Three times shows up twice.

[01:46:58]Four times gets discounted. Five times shows up twice.

[01:47:03]Uh no, five times would only Yeah. Yeah.

[01:47:05]Five times would show up twice. It wouldn't show up once. Now it show up twice. And then six times would get discounted.

[01:47:12]So you'd have one, two, two. You would Yeah, it would. Yeah. Justide by two.

[01:47:17]Okay. It seems a bit odd, but flat count modifier just divide by two. Um, and then that's for the odd case. And then the rising count is it's still going to be like for five it's 2 * 1.

[01:47:37]Um, but this is a different formula here now.

[01:47:49]So what happens now is like for in this in this case it's still just one right because you just have one and two two one two two and one but when it become when it's when it's the odd length subarrays it's 135.

[01:48:13]So this is going to appear in the in one and in five still.

[01:48:27]So that actually doesn't change in that case. We'll come back to that.

[01:48:34]But in this case it would have been one two and one two.

[01:48:40]Um but instead of being one two so the multiply by two I think on both sides is still correct but but um getting 1 plus two here I think is incorrect now because that would be for the one case the five case or the one case and the two case and the three cases where it's the three one case and two case but the two case is gone now that's what I'm saying so yeah it's it's just it's just the odd version now I think it's just temp 2 It might be uh it might be this.

[01:49:58]I'm a little confused by this part.

[01:50:04]It's confusing. Um, so the bound was three.

[01:50:10]We said we're going to add from one to two, but we're going to exclude two.

[01:50:17]And it's going to be the sum of odd values.

[01:50:25]Huh?

[01:50:28]Yeah. If we did the sum of the odd values like where two is the index of the odd value. So like 1 1 + 3 then it would be 2 ^2 which is 4. But it's it's not that it's the odd values that are bounded by this index. So like the odd values less than two for example or less than or equal to two which is a little bit more complex. the odd value the number of odd values that are less than or equal to some number let's say x it's going to be I think just divide by x so say temp modifier so this is going to be squared Um, but this is going to the number of odd values less than or equal to a certain less than or equal to temp which is going to be like one to one to two is just one value. So you could divide by two and that gives you that um three values though you so you would add one divide by two there's a lot involved here a lot of things going on here this is pretty messy I think you add one divide by two and then square that. So, uh, yeah.

[01:52:20]So, for two, you add one to get to three, divide by two gets you back down to one, and then square 1 * 1 is one.

[01:52:28]Um, for four, add one, divide by two gets you down to two, and then square two. So, 1 + 3 gives you four. Yeah. Okay. I think that's really uh, is this correct? I don't know. I guess we'll find out.

[01:52:47]It might be just as it is. No.

[01:52:51]Okay.

[01:52:54]It's a rough one, huh?

[01:52:56]How's Chad doing? What's up, Chad?

[01:53:00]You're probably like, "You're on your own with this one, bud."

[01:53:05]This is definitely um more challenging approach.

[01:53:09]There's probably a much simpler way to do this, but uh this is one way of doing it.

[01:53:15]Um, I'm very tempted to use like sliding window or something or like like a prefix summary or some something that just makes this a lot easier rather than trying to directly compute how many ways each element gets added.

[01:53:32]Although it can be done, I think I'm sure there's a much better way to do this. It's a lot faster.

[01:53:39]Excuse me.

[01:53:41]I might be spending too much time on this quite frankly.

[01:53:46]Um, all right.

[01:54:04]So, I missed something here. Um on the first one I have this temp modifier here. Temp modified this rising count.

[01:54:17]Um apparently this is off by by 10.

[01:54:29]How many times does one get added?

[01:54:40]do something deep here.

[01:54:47]Um, come on.

[01:55:02]I might want to put this on actually this way.

[01:55:13]Okay.

[01:55:15]Let's see what numbers I get here.

[01:55:19]This 1 14253 case I should get.

[01:55:23]So this is the total the number of times. So this is appears one three and five and one time each it should be three not one not two.

[01:55:37]This is off by one. This appears uh once in the one case, twice in the three case and once in the five case.

[01:55:50]So one, two, one.

[01:55:54]Yeah, that's correct. Um so this is right. The second one, this two should appear once in the one case, three times in the three case.

[01:56:07]Um and then once in the five case. So this should be a 1, three, and one. This should be five. So this should be three.

[01:56:16]This should be five.

[01:56:18]Um this should be once in the one case, twice in the three case, once in the one case, and then the last.

[01:56:32]Yeah. So this should be 3, four, five, three.

[01:56:37]Um, wonder if it's that simple.

[01:57:04]Um, three, four, five, 4, three.

[01:57:21]Um, Um.

[01:57:53]Oops.

[01:58:04]Trying to think about this here.

[01:58:07]0 1 2 1 0.

[01:58:16]I got to invert that.

[01:58:26]If I did n minus be five, four, three, four, five.

[01:58:31]Or do the other way around.

[01:58:35]If I added this, I would get five, six, seven, and then I just need to subtract um 56765 minus two.

[01:59:05]Okay. It's wrong, but it's close.

[01:59:11]It's close.

[01:59:14]It's not correct.

[01:59:19]Uh, okay.

[01:59:24]It might be as simple as this.

[01:59:29]Oh, no.

[01:59:37]Let me see in the in the three case it should be 10 gets added once and once and yeah one two three times it's one for one no twice one for one one for three is twice.

[02:00:02]Um 11 is one for one, twice for two, one for three. So it's two, four, and two, I think.

[02:00:18]Okay.

[02:00:20]No, no, no. It's two, two, and two. It's two cross.

[02:00:32]Each one gets added once for Yeah, it's it's just twice all the way across.

[02:00:39]So, this is wrong.

[02:00:43]Um, yeah, this is wrong. Okay, it's a fun idea, but it's not correct. A little bit little more complicated than that.

[02:01:04]All right, let's go back to what I was doing then. Um, oh man, this is involved, huh?

[02:01:14]Uh, let's see.

[02:01:17]So, I said I said it should be 345 or rather I'm getting 242 again twice.

[02:01:31]This one, this one's a little bit easier though. I think this is just one one.

[02:01:34]Yeah. And this one should be two two across the board. Instead of getting one, two, one, it should just be getting 222.

[02:01:42]Okay, so that means this should be slightly higher in these cases.

[02:01:52]Um, okay.

[02:01:56]All right. Uh the So the flat count for the first case should be I think it's going to be 11 one all the way across, right? One zero one 0 one something like that.

[02:02:37]Um and then the rising count is just zero.

[02:02:50]So we say the bound for I equals Z is one temp is zero. Yeah. So this rising count doesn't count at all for the first one. Um but the flat count is it's five minus this temp which we said is uh zero. So five. So it' be two fly count modifier is two.

[02:03:18]which is not correct.

[02:03:20]Um, it should I think it should be a plus one.

[02:03:30]Oops.

[02:03:36]Stream's still live.

[02:03:40]See, just give it a moment.

[02:03:45]Uh oh. Okay.

[02:03:49]Um, yeah, I think that gets a plus one there.

[02:03:57]That might be part of the issue there.

[02:04:01]Oops.

[02:04:17]Okay, there we go. A little bit better.

[02:04:19]So now this is correct, but this one's not correct now.

[02:04:25]So this should be a four, not a six.

[02:04:29]Um, let me think. How does that handle? How does it handle? So it handles for says n - 10 + one. So uh this bound will be basically one temp will be zero. N - 0 + 1 / 2 is 3. Yeah, that's correct. One one three and five gives you three different odd values.

[02:05:09]If we're even at six, you would get uh still get three, which is correct. Okay.

[02:05:18]Um that's the correct flat count modifier for i equals z case when i equals 2.

[02:05:27]Now you're doing 1, three, and five.

[02:05:30]Um but in this case three is the only one that you would consider.

[02:05:42]Um which is where this temp subtraction comes from.

[02:05:48]So now n is basically like six and what do we subtract here? the uh this temp part the bound I think we said is two is one two subtract one is one multiply by two is twice oh it's confusing Yeah, it is confusing.

[02:06:32]Oh my gosh.

[02:06:40]Oh boy, this is getting complicated. Let me Maybe not start over, but remove some of this.

[02:06:58]Let's just remove some of this. Kind of try to think about this a little bit differently.

[02:07:04]I'd start over, but maybe take a fresh look at it.

[02:07:11]Excuse me. All right, let's try this again. So, how many odd how many times is this going to show up in the odd cases? Well, it shows up once for one, once for three, once for five. In fact, when i equals zero and when i equals 5 towards the edges. So, we do we do want we do want this. This is going to be sort of near edge or I'm not sure what to call this. Um, we'll call this edge distance or distance Um that'll be the index and then sort of reversed as well.

[02:08:03]So 012 and then 21.

[02:08:06]Um there's some symmetry here.

[02:08:12]Could even call it like sim symmetric index something like that. index.

[02:08:18]All right. Um, now our symmetric index.

[02:08:27]Uh, what I want to do is count the number of a times the i + one. So, we're going to say flat.

[02:08:51]I guess the flat part of this calculation um that's how many times we multiply by i + one which is the sim index + one not the not i + one the sim index plus one okay um now the sim index + one I think that's what one of the things that changes here um in the odd case zero you get i + 1 at i = 1 you get it should be a two right three and three had in this case it's still three because the three amount reaches us three times but one and five only reach once so it is still a sim index plus one for the flat part. Um, and the number of times it occurs is going to be I guess it's going to be basically the number of times the number of the odd sized subarrays are going to be larger than the sim index.

[02:10:46]Oh, really? Oh, really? The number times the sim index is larger than I'm not sure how to express that actually. Uh so the number of times the there's a lot of symmetry involved here.

[02:11:32]It gets confusing.

[02:11:34]The number of times the oddlength subarrays not only exceed the sim index value um I have to but also those arrays themselves modified should exceed the sim index. So for example like four and five should actually just count as two and one again which is confusing. So the symmetric version or the the reflected version, I'm not sure how to express that. It's like it's not uh it's not four and five compared to the sim index. It's one and two compared to the sim index.

[02:12:38]And it should be exceeding greater than equal to the sim index plus one.

[02:12:43]That's the flat number.

[02:12:46]The number of times that those lengths are greater than equal to 7 x + one.

[02:12:55]And those lengths are going to be um you could just extend it up to the midpoint and then multiply by two.

[02:13:16]But yeah, those those lengths that it's going to be in this case, it's going to be one 31 for the odd ones, right? Because we exclude two and two.

[02:13:30]So the num the numbers we're dealing with are 1 2 3 2 1. the number of times those numbers exceed greater than equal to three.

[02:13:39]Yeah, that's really confusing. I don't even know how to explain that in English. Articulate that. Uh yeah, they're like symmetric versions of themselves.

[02:13:53]Something like that.

[02:14:09]Yes. So, calculating this flat portion definitely is not obvious.

[02:14:16]It's not that hard, but it's definitely not obvious. So, So the number of times that array of elements let's say is greater than or equal to sim index plus one I think can be calculated in a in a a formulaic way but it's just not obvious how to do it. It's not immediately obvious. Um like I said in this case it's going to be 1 2 3 2 1 is going to be the the elements and the sim index ids sim index plus one values are also going to be 1 2 3 2 1 um so obviously the first time the number of times you exceed one oh n where don't include the the even value so it's 131 rather than 1 2 3 2 1 be 1 131 so the number of times we exceed one is three times number zero. Oh yeah.

[02:15:23]Number times we exceed one is three times. Number of times we exceed two is once. Number of times we exceed or greater than equal to three is once. Um and the number not exceed but greater than equal to one. It's three times one time for two. One time for three, one time for two again and then three times for one again.

[02:15:44]So it becomes 3113 is this flat amount which I think is correct by the way.

[02:15:52]Yeah, that's really confusing.

[02:15:58]This is really confusing.

[02:16:00]Um, how can I encode? How can I compute this? Um, one, two, 3, two, one. So if it's an odd number that we're dealing with, let's suppose we remove it for the for the sake of argument because I can say we're just going to double the number of times. So we can split this into two components. Um to flat even and then odd portion odd portion.

[02:17:03]If it's if it's even, we can just double this part, which is going to be um the number of odd numbers that are less than or equal to it' be sort of like n minus one or something.

[02:17:38]Oh, what did I say it's going to be? So with five, the largest number you get is three, which is n + one by two.

[02:17:50]That's the largest value you get.

[02:17:57]computer is struggling here.

[02:18:01]Um, but actually that's not the part that we're going to double. We're actually going to subtract one, I think, and divide by two instead.

[02:18:14]If it's odd, that's if it's odd. If it's even, we don't need to subtract one.

[02:18:27]Yeah. Four. The largest value is two.

[02:18:35]Yeah. If it was it was four be 1 2 1 which is symmetric, right?

[02:18:45]So I think we only subtract one if it's odd.

[02:18:51]Um, and I don't think you need to subtract one if it's odd, by the way, because this will automatically when you bit shift it'll remove that.

[02:19:03]Doesn't matter. Okay.

[02:19:06]So now that gives me the upper bound on um the number of odd numbers.

[02:19:22]Oh, this is peculiar, huh? Look at this.

[02:19:26]Look at that, man.

[02:19:31]Oh my gosh. Oh, you got to be kidding me.

[02:19:43]Okay. So, it's the number of odd numbers.

[02:19:50]How's stream doing by the way?

[02:19:58]Okay.

[02:20:01]So here you would have five / two gives you two and then I'm saying square that and bishop to the left. I don't think that's right by the way.

[02:20:14]Um 5id by two is two.

[02:20:30]Hold up. Um, I'm sorry it's really hard to focus. Um, give me a second.

[02:20:51]There we go. Um, this is so confusing. I'm sorry. I'm also like distracted a little bit, too.

[02:20:57]Um, all right.

[02:21:03]This isn't the right one so far. Let me just you've got this symmetry, right? We're going to remove the odd part.

[02:21:16]So we consider the largest value you can go up to is going to be two or five. So yeah, and n divided by n bit shifted to the right by by one is probably fine.

[02:21:28]Um, and then what happens is we want the number of odd numbers that are less than or equal to this value two.

[02:21:43]The number of odd numbers that are less than or equal to that value. So, let's just do uh standard helper is not so simple. Um that's going to be I think add one and bit shift by two again.

[02:22:16]So the number of odd numbers that are less than or equal to two I think it's just one right. So you add one to three divide by two you get one about three.

[02:22:31]Yeah. So then and then and then this odd helper squared this is the number of and then you shift that by two.

[02:22:47]Oh yeah, that's really confusing.

[02:22:50]It's so kind of ridiculous.

[02:22:54]So yeah. Oh my gosh, man. Oh my goodness. Oh, okay.

[02:23:07]I didn't choose the le code life. Le code life chose me.

[02:23:15]I think that's correct. That's so messy, but I think it's correct. Uh, it's also make sure I have the right number of um All right.

[02:23:30]So we're going to just consider the odd portion. So 5 / two is two. Uh counting the number of odd numbers that are less than or equal to two. We're going to add one and divide by two. And then you can square that number to get the sum of all those odd numbers. Okay?

[02:23:54]And then this is the even part. Um, and this is the even helper actually.

[02:24:06]Um, and then what's going to happen is, uh, we multiply that by two because it's on both sides, right? From left to right and right to left. We're adding that together.

[02:24:24]Um that yields the flat even portion.

[02:24:33]The flat odd portion I'm sure there's a way to optimize this.

[02:24:56]By the way, somehow my computer is starting to struggle with this.

[02:25:02]Um the flat odd portion I think is a lot simpler. It's just going to be um basically this n / 2 greater than equal to sub x + one.

[02:25:28]Um I think it's like this.

[02:25:39]So if it's five divided five becomes 6id by two is three.

[02:25:47]Um six would still be three. 6 + 1id by two be three. Yeah.

[02:25:56]Um this is yeah six would be zero one two three. Yeah. Yeah. It's just it's just the sim index portion. So um yeah, it's going to be n and one.

[02:26:23]So this flat odd portion is just a check if this is if it's an odd sized array.

[02:26:31]Then we're going to check if um if that point that we've removed exceeds the sim index or not. So sometimes we add this extra part and sometimes we don't.

[02:26:46]Okay.

[02:26:49]Um so that's the flat flat portion. Uh yeah.

[02:26:55]Okay.

[02:27:00]Um, now the rising portion.

[02:27:10]All right.

[02:27:20]Um, this is not going to be the sim index plus one.

[02:27:35]This rising portion is a little more complex.

[02:27:40]It's zero in this case. There's nothing rising there. In this case, it should be a one and it should be a one on both sides.

[02:27:50]Um the three count has the sim index number. The five count only has a one.

[02:28:01]That's part of the rising portion. So you multiply the rising portion by by two.

[02:28:08]Um and yeah, my computer is struggling now.

[02:28:18]I don't know why but it is struggling.

[02:28:21]Uh now how would I compute this? Um it's very similar to what we just computed the flat count but It's It's a little different.

[02:28:58]It's more like It's more like this flat even portion.

[02:29:14]I wonder if that's correct.

[02:29:34]I wonder if it's just this flat even portion.

[02:29:37]That might be the same thing. I don't know.

[02:29:47]That's confusing. Um, let's make this uh let's make this just without the multiplier there.

[02:30:04]Oh, yeah. I don't I don't know what's going on, but the the browser is definitely having a really hard time.

[02:30:08]The computer's having a hard time.

[02:30:11]It might just be.

[02:30:16]Could be a few things.

[02:30:20]I suspect this rising count is is basically the same as this flat even portion.

[02:30:28]It's the same thing. That's actually what I'm trying to calculate here.

[02:30:34]By definition, I won't have the flat odd portion. I think it's just the same thing.

[02:30:45]What happens if I do this? I think it's the same thing. I could be wrong, but compiler Uhoh.

[02:31:19]Um, wrong answer.

[02:31:32]581185. phone. No, that's much too large. Okay.

[02:31:40]Oops.

[02:32:01]Oh man, this is going to be rough, huh?

[02:32:08]Have to keep that in mind for the future.

[02:32:13]Sometimes the computer struggles lagging.

[02:32:25]So flag count I got three which is correct.

[02:32:28]Rising count should be zero.

[02:32:32]Flat count is six. This is wrong. Fly count should be um one.

[02:32:39]Okay. fly count's incorrectly computed as well as the rising count.

[02:32:43]Both of those are wrong.

[02:32:46]Okay, let's go back. Let's make sure the fly count's right. So, that's supposed to be one.

[02:33:01]Oh no. Oh, I may have to cut the stream early. the computer's if it's going to keep doing that that's going to be kind of an issue or like basically like buffers the end. Um where was I?

[02:33:18]Why don't you use DP programming? What's up uh Tahuain?

[02:33:22]Howdy. Um I you know it's not a bad idea to try to use DP here. There's a couple reasons not to use DP. So one reason is that I think this can be done in linear time with constant memory.

[02:33:39]If you use DP for this then you use extra memory. Um so I think there is a better solution that doesn't involve DP.

[02:33:47]That's the first reason. Second reason is that I don't see the DP solution immediately. I have to think about it.

[02:33:52]um the DP solution might be a lot faster to program like in if you had like time bounds then I would say using the DP solution in that case is probably best but the reason I'm not doing it in simple terms is that I think there's a way to do this that's more direct it's just not obvious um and I'm struggling to kind of formulate it correctly all right so the flat count at six at two. Yeah, at four should be six.

[02:34:30]So, this was incorrect. Um, so I had five this even helper five / two is 2 + 1 is 3id 1id two is one.

[02:34:50]So my even helper should be one and then the flat even portion I get 1 * 1 bit shifted by two is two and then I get this flat part is two plus something else. So this is wrong.

[02:35:05]This should be a one.

[02:35:09]Um yeah this is not quite right. Uh, it's even help us.

[02:35:35]Um, I'm also kind of surprised because this Oh, right. Um, yeah.

[02:35:58]So, this is um Um, I want to say this is more like sim index or something.

[02:36:18]That might be where it's supposed to be.

[02:36:27]And yeah, this is the lag is getting pretty intense.

[02:36:33]I think it has to do with I might have to just refresh code or something.

[02:36:44]Oh man, this is super awkward.

[02:36:48]Um, no, that's not the I don't know what was I thinking before this flat count. This is wrong. It's definitely wrong. It's supposed to be 311 31113.

[02:37:04]for the flat flat amount. The flat count and then the flat count is then multiplied by the sim index plus one.

[02:37:16]This is wrong. This is very wrong.

[02:37:20]Uh let me think about this for a minute.

[02:37:23]Oh man, what did I do wrong there? Um, it's the number of oddlength subarrays that when I guess reflected, meaning uh you take the the length and you take n minus the length plus minus one I think so like 1 3 and 5 becomes 1 3 and 1 it should be so it would be I think it's n - i + 1 5 - 5 + 1 2 would be no it's n - i minus one no uh uh I think it's n minus i it should be 1 2 3 2 1 so one should be one that's the minimum of those two things of a minimum of i and n - i + 1 or n - i minus one so if i is 1 you get 5 - 1 - 1 is 3 should get one when i is 2 5 - 2 - 1 is 2 which is should be correct as two and then 3 5 - 3 - one.

[02:39:25]No, that gives you one again. That should be three.

[02:39:29]I think it's I think it might be + one.

[02:39:32]Five. N - I + 1.

[02:39:37]5 - 3 is 2 + 1 is three. Yeah. And then 5 - 4 + 1 is 2. 5 - 5 + 1 is one. Yeah.

[02:39:47]Take the minimum. So, it's going to be the minimum of I and N - I + 1.

[02:39:53]Um that's like the reflection that's happening and then where I I is the length of the subarray.

[02:40:08]And then we're going to count the number of those reflect the subarrays. The subarrays that are odd and have a um a length that's you know reflected length. I'm not sure what the right word is for that. I'm calling reflective, but I'm not sure what the right right phrase is. Uh that's less than or equal to um the sim index plus one or excuse me, it's greater than or equal to sim index plus one.

[02:40:42]Um interesting.

[02:41:03]Okay.

[02:41:04]Um All right, let's try this again.

[02:41:25]depending on what the SIM index is.

[02:41:39]And depending on what N is, it doesn't really matter as much what N is. It matters more what the SIM index is.

[02:42:01]It's very confusing.

[02:42:13]How many of those values are greater than equal to the sim index?

[02:42:22]And then I'm going to double that. So that makes things more confusing, too.

[02:42:32]Oh.

[02:42:34]Oh, I'm making this so much more complicated than it needs to be, I think. Probably.

[02:42:40]Um, gota think about it. Gota sit and think about it for a while.

[02:43:28]I think I could just use the sim index plus one and then count the number of arrays that are greater than or equal to Right. Well, the the thing that makes that confusing is that the the arrays themselves also have that kind of symmetric property, which is why this is complex um or more complex. Uh let's just let's just remove the odd port part so that way we can just double the Yeah. Yeah. Okay. Okay.

[02:44:12]That's what I did before.

[02:44:14]is that we're going to remove the odd part al together and compute the even portion which is just going to be a doubling of um it's basically just like the send index with some modifications.

[02:44:30]Excuse me. So also I think I got to refresh the page or something. Let me let me try that.

[02:44:40]Let me try refreshing this. See what happens.

[02:44:43]Hopefully that fixes whatever is going on here. It's starting to like really lag for some reason.

[02:44:53]Um I'm not sure what the lag is from.

[02:45:03]Uh yeah, it's not good.

[02:45:09]I might I might need to I think I'm okay.

[02:45:13]I think I might want to restart the stream because this is my browser is starting to crash here.

[02:45:22]Yeah, this is a bit awkward. Okay, sorry folks.

[02:45:31]I might just I might just need to restart. Yeah, this is really uh uh something's not right. All right, let me try to solve this question and then I think I'm going to restart afterwards because this is not quite um this is going much slower than it should.

[02:45:59]All right. Um, see my think my thinking here is that the I've got to count for that sim index plus one which for five is going to be 1 2 3 2 1 um I've got to count the number of oddlength um subarrays that are greater than or equal to that particular sub index plus one and the number of those arrays and it's not just the oddlength arrays but this oddlength arrays modified suddenly they would be instead of 1 2 3 4 five it would be 1 2 3 2 1 and then if it's only the odd ones it's going to be 1 three and one so I've got to count in that way which is a little bit more complicated um so the way I decided to do this is exclude the sim index one plus one value that's going to be odd and count that separately.

[02:47:03]Uh or the array value that's going to be odd.

[02:47:07]Um which actually mirror the sim index mirrors the array values. So, it's really only if it's really only if I is uh is in the middle of the array. Quite frankly, it's the only time where this really gets complicated is when I is in the middle of the array.

[02:47:44]So, we're just going to say if i equals um like if if n and one and i equals array size or n / one Just have to be careful because of this.

[02:48:21]Then we're going to do something different. But other all the cases I think we don't I don't need to be that careful.

[02:48:41]Okay.

[02:48:44]So, in these cases, I actually don't need to care about that middle portion at all. Um, and so I can just say, uh, get the sim index, add one to it. um or sim value we'll call it.

[02:49:11]So I don't really even need the sim index value or sim index itself. It's a symmetric value. Um and then I'm going to count the number of odd numbers there are which is going to be something like this.

[02:49:32]number of odd numbers that are less than or equal to that sim value. So if the sim value is two, um the number of odd values that are less than or equal to oh yeah, that's right.

[02:49:48]The number of odd values that are less than equal to two, it's going to be 2 + 1 divid by two is 1. And then number of odd values that are less than equal to 3, 3 + 1 divid 2 is 2.

[02:49:59]which is right to get one and three.

[02:50:00]Yeah. And then then the even helper squared. Um and then we double it as well to get the portion.

[02:50:08]Um and then the flat odd portion we don't even need don't need that unless it's unless it's the uh Oops.

[02:50:36]The flat count could put down here.

[02:50:59]All right. Um, oh, excuse me. I forgot. Okay, my mistake.

[02:51:17]Um yeah, I'm just gonna like to do come back to that.

[02:51:27]Uh I think this flat even portion is correct.

[02:51:33]Um we'll come back to the rising count later.

[02:51:37]The flat count.

[02:51:43]Yeah.

[02:51:53]This should be something like this. Confusing. Uh what do I get for mix?

[02:52:24]Okay.

[02:52:30]Um, this is maybe a lot more time than is required for this question.

[02:52:42]But it is um meaningful here.

[02:52:52]I'm not going to commute these other parts here for now. We'll just leave this leave this as it is.

[02:52:58]I'm just interested in the flat part for now.

[02:53:03]Okay. I got 32.

[02:53:08]All right. Uh should not be 32.

[02:53:25]Uh this should be initially one.

[02:53:36]Oh, that's fine.

[02:53:44]Okay. Two.

[02:53:47]It really should be three. The flat part there should be three initially.

[02:53:54]Um.

[02:54:11]Oh, I do have to add the odd portion, don't I?

[02:54:16]It's so confusing. It's very confusing.

[02:54:22]Yeah. Uh the I do need to have the odd portion. The reason the odd portion needs to be there is because this is the number of it's the number of subar odd subarray lengths that are slight they're modified so that way they reflect um like one two 321 rather than 1 2 3 4 5 that are greater than or equal to the sim value at that particular index.

[02:55:15]Um, so the reason I still need this flat odd portion regardless of whether or not we're looking at the middle point is uh because I need to add that that three that's being counted.

[02:55:35]That's pretty annoying. It's really annoying.

[02:55:40]No. All right. Uh, yeah.

[02:55:46]Okay.

[02:55:51]Yeah. Three is always going to be greater than equal to the this odd portion will always be there.

[02:55:58]It's always going to be greater than or equal to uh symbol.

[02:56:07]So really this is just one to odd quite frankly.

[02:56:13]Um, not assert or cast.

[02:56:23]That's really annoying.

[02:56:25]That's really annoying.

[02:56:30]Yeah, it's just always going to be there, I think. Uh, there's no way around that.

[02:56:37]Let's try again.

[02:56:40]My gosh, man.

[02:56:52]Flat is three. Okay, got it. But these other ones, flat should be one across the board.

[02:57:02]So it should be 3111.

[02:57:07]That's annoying.

[02:57:09]3393. What is this?

[02:57:17]This is wrong as well. So, it's not the number of odd values that are less than or equal to sim value. It's the number of odd values that are greater than or equal to sim value. So, it should be getting smaller, not larger. Uh, it's another mistake.

[02:57:41]Oh, that's confusing very much. So, it did.

[02:57:52]Okay.

[02:57:53]Um, how do I calculate how many odd values are greater than equal? Greater than equal.

[02:58:09]Uh, I could subtract. Could do it that way.

[02:58:20]So, we're not going to multiply by two.

[02:58:23]This flat even portion is going to be multiplied by two.

[02:58:32]Um the even helper it's going to be so this is the number of odd values that are less than or equal to some value.

[02:58:53]We want the number of odd numbers that are less than or equal to n.

[02:59:00]minus the number of odd values that are less than or equal to the sub value.

[02:59:07]And that gives me the number of odd numbers that are greater than the sub value.

[02:59:16]Well, we want greater than or equal, not just greater. Um, and we also want if n is odd then we don't want to uh we don't want to count the larger value for n. So like if n is five we don't want to count three in there. We want to count just two odd values less than between you know less than equal to two rather than less than equal to three for reasons mentioned previously.

[02:59:53]Very confusing. I know. Very involved.

[02:59:58]Um, I'm going to charge my computer again.

[03:00:02]Give me a minute.

[03:00:24]Okay. All right. So, um, yeah, this also gives me values that are greater than the sim val, not greater than or equal to the sim val. So, I should actually subtract here.

[03:00:43]Subtract one instead of add one. Okay, that's a little more what I'm looking for.

[03:00:49]Complicated complicated.

[03:00:53]Um, fly count is five. Okay, better. It should be one one 5115.

[03:01:01]It's much closer. It should be 311.

[03:01:06]That is much better. Um, maybe this is right then. Actually, there's a plus one.

[03:01:18]No, no.

[03:01:25]There's something slightly wrong here.

[03:01:39]Okay. I know what's wrong.

[03:01:42]I know what's wrong. Um, all right.

[03:01:56]Okay. It's going to be this minus this.

[03:02:08]Something like that.

[03:02:19]Although with some slight variations I think.

[03:02:24]No. Nine. No, it's too big.

[03:02:29]Maybe this is plus one.

[03:02:43]I don't think this I have to think this through a little bit more.

[03:02:55]Oh boy.

[03:02:57]No.

[03:03:01]All right. So, this is a tough one.

[03:03:23]Okay, let's try again.

[03:03:26]We're going to say constant Um odd count one.

[03:04:01]Odd count two.

[03:04:23]And then this even helper is the difference between these two. Odd count one minus odd count two.

[03:04:38]It's yeah odd sum one odd sum two.

[03:04:46]Now, as I mentioned, the idea is that you've got a certain number of elements that you want to know how you want to count the number of those elements that are greater than or equal.

[03:05:06]And these are odd. And actually, I don't need the sum of these. That's a mistake. That might be what I'm doing wrong here.

[03:05:18]Excuse me. That might be a mistake.

[03:05:21]I think I just need to count.

[03:05:29]That might be one of the errors.

[03:05:33]Yeah, I just need to count how many there are. I don't need to know the sum of those.

[03:05:41]Okay, a little bit closer. Three. It should be 3113, not 33133.

[03:05:47]Um so in this case five / two is two and then val of one.

[03:06:18]Two / two is one. This should be 2 minus one is one. So even helper is one.

[03:06:26]Multiply by two. This is odd at one. So it calculates it correctly for the first one. And the second value same thing and it's two symb um two one 2 - one is one.

[03:06:51]Um I'm supposed to get zero for this one or one zero for the flat even portion.

[03:07:07]That's a tough one, huh?

[03:07:15]This is wrong. This is not supposed to be two. It's odd count one. I don't think it's odd count that one's ever supposed to be two. It's supposed to be 135 becomes 131.

[03:07:49]Um, yeah.

[03:08:02]This is supposed to be a one.

[03:08:11]Yes.

[03:08:15]If n is even, this ends up being n over two.

[03:08:22]So six would be like one, two, three.

[03:08:30]Number of odd values less than or equal to six.

[03:08:44]Ah, it's really the number of odd values that are less than equal to three, which would be n / two.

[03:09:02]I think divide by two again.

[03:09:08]It's a little odd, but I think that's correct.

[03:09:16]Okay. No.

[03:09:20]Now one one negative one. Oh my gosh, dude.

[03:09:26]This is like my gosh.

[03:09:38]What's even going on?

[03:09:41]What is even going on?

[03:09:46]Number of odd values.

[03:10:21]Oh my gosh.

[03:10:33]Hold on a second. Let me think about this for a second. So I want the number of odd values that are less than or equal to n / two. If n is five, we get number of odd values less than or equal to two. n is six, number of odd values less than equal to three, which when you divide number of odd values less than equal to three.

[03:10:54]So it's going to be + one two.

[03:11:01]Yeah, confusing, but that's that's the right one.

[03:11:06]Um, five divided by two is two. Number of odd values less than or equal to two is going to be 2 + 1 divid by two is 1.

[03:11:15]3id 2 is 1. Number of odd values less than or equal to uh divid by 6 by two you get three. Number of odd values less than equal to three. 3 + 1 is four divid by two is two. You have one and three.

[03:11:26]Yes, that's right. So there's the number of odd values that are less than equal to two.

[03:11:31]Okay.

[03:11:35]Then we want the number of odd values that are less than or equal to the sim value less than or equal to the sim value.

[03:11:46]Um which should be actually some value this one.

[03:11:55]And then we can take this difference.

[03:11:58]I realize this is very confusing.

[03:12:04]This is still wrong. Okay. Of course it is.

[03:12:12]So brutal. It's so brutal. Oh my god.

[03:12:18]It's a rough one. It's a rough one.

[03:12:22]Let's try again. Um so for i is zero. we get the same value of one.

[03:12:29]Number of odd values that are less than or equal to one should be one which is what we get.

[03:12:37]Um this is less than or equal though we subtract one because we want don't want less than or equal. We want less than.

[03:12:51]That's four because when we subtract on the other side odd count minus one minus two we want greater than equal not just greater than. Okay, there we go. Now it's correct. Oh, it took so long. Took so long. How many hours did that take? Oh my gosh.

[03:13:12]Took like hours. It's brutal.

[03:13:17]It's very brutal.

[03:13:19]Um okay now uh the flat so that's the flat even portion counting the odd values and then the odd portion we add we just add so that gives us the flat amount okay finally that took took a while now the rising amount is a little more complex um that's going to be the uh we're not just counting the number of odd values now now we're taking the sum over those odd values and these are not going to be the odd values that are greater than or equal. These are going to be the odd values that are less than.

[03:13:56]So now this is more like um this odd count um it's similar to this odd count odd count three.

[03:14:24]Okay, this is going to be the number of um odd values that are less than or equal to the sim value which is going to be like this.

[03:14:54]Um and this one can we compute a sum?

[03:15:04]Now is it less than the sum value or less than or equal the sum value? I think it's less than the sum value. Not less than or equal. I think it's actually less than which would be the same thing as this odd count actually.

[03:15:20]So it's actually odd count too.

[03:15:27]Oops.

[03:15:34]And then we square that odd count too to get the sum over those odd values.

[03:15:43]Um and then Yeah. And those are we're not going to multiply by the same value by the way.

[03:15:57]Fly count and rising count. We add those together.

[03:16:06]Oh man.

[03:16:08]Is that complicated or what?

[03:16:13]Raw mount three flag count one oh no the fly count should be here should be oh yeah yeah this amount should be the rising count whoops did that wrong this is multiplied by two by the Okay. So now we get the right answer.

[03:16:55]Finally.

[03:16:59]Fly count three, rising count zero. Fly count one. Uh fly count. Yeah. Two. And the rising count is two.

[03:17:06]Gives you mount four.

[03:17:13]And then five. Three, four, five. Fly count three. Ro count two.

[03:17:22]Uh, that gives you five.

[03:17:32]Yeah, because even though it's a one, multiply by three.

[03:17:40]to get three. And this other one's two.

[03:17:47]Okay, so that one's computed correctly, but the other ones are not computed correctly, which is annoying.

[03:17:54]Um, six. It should be three.

[03:18:02]Flat amount is two.

[03:18:05]the first one which I think is probably wrong.

[03:18:12]Um it appears twice once in one and once in two.

[03:18:23]So that's correct.

[03:18:26]Rising count is zero. Flat count is Yeah, that's actually correct. It's two in mult both cases.

[03:18:33]Um Um, wait. They said there should be three one. Oh, but it's odd. The odd the odd ones. Oh, I see. Um.

[03:18:50]Oh, I see. I see. Um, in this case, you don't have 131. You just have one.

[03:19:04]Oh, I see. Okay.

[03:19:07]It would be like one, two, one, but the two and the one. Yeah. Okay. All right.

[03:19:12]That's a little bit odd. Um, I think this works for cases that are larger than one and cases that are larger than one, one in three.

[03:19:48]I didn't check what the test cases are.

[03:19:50]That was one,000 only. Okay.

[03:20:07]Oh, it's wrong in this case still. Oh, no.

[03:20:18]H, it's a bummer.

[03:20:23]Okay, so it's still wrong, but closer.

[03:20:28]Um, I might want to take a minute to breathe here.

[03:20:37]It's a tough one, man.

[03:20:40]I could have just used the uh the more basic approach and just went straight through. But like the quadratic time solution, but I believe there is a linear time way to do this that's that doesn't use extra memory. Um, it's just a little bit involved.

[03:21:02]Ah, that's a bummer. Okay, let's try to fix these smaller cases first and see where what I what happens.

[03:21:14]So, okay.

[03:21:25]We're not correct. Um it should be zero in this case.

[03:21:31]Um okay.

[03:21:41]So 2 / 1 is 1 + 1 is 2 / two is one. So I'll count one of one.

[03:21:52]The sin value is zero. So this is this is wrong. Um why should the flat amount be zero here?

[03:22:18]Uh the reason is it the reasons that the this wondering if this should always just be one.

[03:22:44]You just always add this portion.

[03:22:55]Excuse me.

[03:23:19]I'm missing something important here.

[03:23:29]So what I was suggesting was that in this test case um you have five three and one covers one once each time.

[03:23:53]Actually, maybe that's easier is to just count the number of oddlength subarrays that um include this value.

[03:24:21]One does.

[03:24:23]Two does. Well, two does it twice.

[03:24:27]Three does. Three does it three times.

[03:24:30]Oh, no. Three does it twice.

[03:24:32]Four does it twice. Five does it once.

[03:24:35]That's kind of what I was trying to compute.

[03:24:38]That there are like different ways you can understand this. I guess um Oh man, I mean it's so complicated.

[03:24:51]simple way.

[03:24:55]Just think about this. It makes a lot easier. Um, yeah, that's what I was trying to capture there with the flat portion was that like how many times does Do the arrays capture it more than once?

[03:25:24]Um, yeah, it's kind of a wonky way to do it, quite frankly.

[03:25:35]Uh, this gets captured once by size one and this gets captured once by size one and size two is just completely ignored.

[03:25:57]So would that be considered the flat part or the rising part? Well, the rising part as I described the flat part basically is the peak where um the most the most subarrays cover that element.

[03:26:27]Um so this one only one of them covers it three times.

[03:26:42]This one is covered twice by three.

[03:26:48]This is 3 1 3 1 3 times.

[03:26:58]And this one it's covered by its maximum three times.

[03:27:15]This is covered by its maximum, once, twice.

[03:27:27]Oh no, but it's an odd number of times, right? Odd length numbers. So it's this is this value is covered by its maximum.

[03:27:39]Three covers it twice and four covers it. No. And that's it.

[03:27:48]Actually, just one time.

[03:27:51]This is just once. And then this is um also once um this is covered by its maximum three times though.

[03:28:20]All three lengths cover it.

[03:28:31]What?

[03:28:35]Okay.

[03:28:51]Same thing on the other side.

[03:28:55]Symmetric or mirrored.

[03:29:00]Then what about uh what about um the other arrays? How many times those cover? So this is all three of the subarrays maximally, right? Times one.

[03:29:23]This is the first subarray covers it once, right? Size one. The size three covers it twice and size five only covers it once.

[03:29:38]So it's three, four, five, four, three.

[03:29:47]This one it's just there's only one subarray that matters. It's just one side length one.

[03:29:56]Um this one length one covers each one once.

[03:30:01]Length three.

[03:30:04]Oh, you know what? Actually, maybe I should use a sliding window approach.

[03:30:12]Um, I don't think there's anything you need to do dynamic programming here though. I don't think so.

[03:30:59]Let me let me see something here.

[03:31:05]Let's Let's do some Let's do some things.

[03:31:22]Okay, let's do like 10, 15, 20, 30, 23. It's just actually small numbers.

[03:31:31]One, two, four, five, six, seven, eight.

[03:31:39]Okay.

[03:31:41]Length one. 1 + 2 + 5 + 8 + 9 like three. 1 + 2 + 3 + 2 + 3 + 5 Um 5 6 + 7 6 7 8 7 + 8 Okay.

[03:32:44]Um, one, two, three, four, five. One, two, three, four. Yeah. And this gives me something like the following. 1 + 2 * 2 + 3 * 5 3 * 6 3 * 7 It's 2 * 8.

[03:33:12]This is kind of what I'm trying to express here.

[03:33:17]Um that you can calculate this number directly.

[03:33:28]Um and then for five light five You get a very similar picture but one two three four five one two three four five one two three four five So you would you would go up to three.

[03:33:56]So 1 * 1 + 2 * 2 + 3 * 5 + 3 * 6 3 * 7 3 * 8 + 1 * or 2 * 8.

[03:34:15]Yeah, you got one, two, three, and then kind of stop at three.

[03:34:20]And then these sums are going to be 1 + 1 + 1 * 1 + 2 * 2 * 2 + 2 + 2 * 2 + um 1 + 3 + 3 * 5.

[03:34:46]Oh no, actually it starts off this is initially a one.

[03:34:52]+ 1 + 3 + 3 * 6 1 + 3 * + 3 * 7 + 1 + 2 + 2 * 8 + 1 + 1 + 1 * 9.

[03:35:19]So, this is kind of what I'm getting at.

[03:35:22]Um, hopefully this makes some sense.

[03:35:29]I really love how you tackle each and every problem. Yeah, I appreciate that.

[03:35:32]Thank you. Yeah, absolutely. Deb Morer Desgupta, welcome. Yeah. Oh, yeah. I do everything. I do everyone, dude. I do every problem. Oh, yeah. I I do I do in the interest of time like sometimes skip problems a little bit, but like I try to go through everything. I like will eventually re return to problems if I have the time time for it. Um but I basically like to do everything. Yeah.

[03:35:55]Um thanks. Thank you. That's that's a big I'll take that comp that's a big compliment. That's something I strive I strive for. So this is kind of what I'm getting at. Like I'm trying to visually understand like what these numbers are going to be in sequence.

[03:36:13]Um, this is why I'm I'm saying that I think this has a pretty clear pattern.

[03:36:17]It's not an obvious pattern, but it's a clear pattern. Um, like it's not not obvious what it is, or it obviously has a pattern, but it's not obvious what the pattern is. I'm not sure how to expl I'm not sure if it's clear or obvious which one it is, but there's a pattern for sure, but it's not so obvious what the pattern is. And this is what I'm trying to get at is that um independent of the numbers themselves, there's clearly a pattern that depends on n and the index that you're on on in this case it's 3, five, 7, and then seven repeats one, two, three times.

[03:36:58]So maybe I can use that pattern um where it'll go from 3 5 7 and it'll probably if n is larger it'll keep going up to 9 11 etc. But just keep iterate chaining an odd by an odd amount.

[03:37:21]Excuse me. Starting with three being I think basically n plus one divided by two.

[03:37:30]Um, so n plus one divided by two is probably where it starts. And then you add two at each each element.

[03:37:37]And then when you get to somewhere in the middle, then you start subtracting two. Then then it's then it stays the same. And then after a certain point, you start subtracting two.

[03:37:54]I would Oh, how do I know how far this should go?

[03:37:59]Um, and is it correct that I would add two at each point?

[03:38:07]I don't think I add two at each point. I bet you it's a little more complex than that. So, let's do So, I said one, two, three, four, five. Oh, I actually I'm not quite right here.

[03:38:20]There's actually six and seven here.

[03:38:24]Yeah, I missed seven. There's one more element here that I'm missing.

[03:38:41]Does very much start to look like Pascal's triangle, doesn't it?

[03:38:52]Yes. So that's Yeah, I missed um seven. So we have one, three, five, and seven here.

[03:39:03]So I forgot seven.

[03:39:07]Knight seven repeats.

[03:39:12]Um, that's also some of the symmetry that I was describing before too that like the the lengths like one three and five and seven are actually equivalent to each other. So you can just do one and three and then double it and you'll get the right the same answer.

[03:39:32]Um, but this ends up being four 6 8.

[03:39:43]But let's do something a little more complex. Let's do uh let's do Whoops.

[03:39:59]Hopefully I can do this.

[03:40:05]Did it work? Oh, it did. Okay, let's do um uh let's do let's do like this. X1, X2, X3 with X0, X4, X5, six, seven, X8.

[03:40:28]One, two, three, four, five, six, seven, eight, nine. All right. Now, if I do nine elements, I'm going to get nine * 1 * x0.

[03:40:43]Now, this is going to increase to I think 7 * 2 + 2 * x1, which is kind of what I was trying to capture before.

[03:40:56]Um, yeah. And then this one is with the flat part. This is kind of what I was referring to with the flat part.

[03:41:05]Um, this is going to be 5 * 3 I think + 2 x2.

[03:41:20]Is that right? 5 * 3 + 2. Um, is that correct?

[03:41:34]Well, how would I say there's going to be one, two, three, four? It's 1, three, five, 79.

[03:41:48]Um, I'd expect a similar thing for 1357 as this pattern, then a nine there.

[03:42:02]So, I was wrong. There's not going to be nine ones. So, it's going to be one, two, three, four, five ones. Not nine, five ones.

[03:42:11]And then two of those ones are going to be relegative here.

[03:42:18]And so I have three twos, not not five twos or not that many twos. And then I suspect I get something like this.

[03:42:31]So is it right that I get this these three * 5? Yeah, I do 3 * 5 here and then length five.

[03:42:51]Length five repeats I think length length three. Yeah, it repeats length three.

[03:43:06]Let me see. Actually, I think uh um I think actually it's not going to be 3 * 2, it's going to be 3 * 3 here on length three.

[03:43:34]Yeah. Interesting.

[03:43:46]Oh, wait, wait, wait, wait, wait. So, that's confusing, right? Maybe I should go through it again.

[03:43:52]I I don't quite have the pattern yet.

[03:43:57]Okay, let's try this again.

[03:44:05]Um, we're gonna say oops.

[03:44:15]Scaldron kind of moves me all over the place here. So, X0, X1, X2, X7, X9, X8.

[03:44:32]Um that's like the f the first one is looks like this.

[03:44:39]The second one when you have three you have x0 x1 it's x2 then x1 x2 x3 x2 x3 x4 and we're just going to say dot dot dot Okay. And the result should be x0 * 1 2 * x1 3 * x2 3 * x3 2 3 * x4 x5 Um, three times X6 Excel draw kind of moves my cursor around in a way. It's a bit odd.

[03:45:54]Eight. Um, interesting. So, length five is different from length three in this case.

[03:46:09]Uh this is going to be so length seven repeats length three with * x0 + 2 * x1 3 * x2 x 3 3 * x4 3 * x5 + 3 * x6 * x7 + 1 * x8 Length nine repeats length one with x sub0 + x sub1 like that x sub 7. See, um, line five is going to be zero, 61. This is two, three, four, one, two, three, four, five.

[03:47:14]+ x1 + x2 + x3 + x4 + x5 x2 + x3 x 64 x 65 x3 That was only four 6 x 6 + x7 which gives me 1 * x 0 + 2 * x1 + 3 * x 2 + 4 * x3 5 * x 4 + 5 * x5 5 * x6 + 5 * No, not x7. No, it goes back down to four.

[03:48:19]X7 actually I think it goes down further. X8.

[03:48:23]So it should actually go down to one here.

[03:48:29]Two.

[03:48:30]Three.

[03:48:33]Okay.

[03:48:36]So, this is kind of what I meant by the flat part was that this section where it's five, this other section um where it's three across.

[03:48:50]This is kind of what I was referring to.

[03:48:54]Um so, this is interesting, right? Um, so now the four things that we add together for one is going to be one across or no it's five. It's five things.

[03:49:14]So x0 looks like that. X1 is going to be one, two, three, two, one.

[03:49:24]I think uh that's length five, seven.

[03:49:36]Um yeah, length five is peculiar.

[03:49:44]Um so length nine and length one are both ones.

[03:49:52]Length Um three and length seven are both um twos.

[03:50:15]Um and lane five is interesting.

[03:50:20]L five I think is also a two.

[03:50:23]No, five. Yeah, on X1 it's a two.

[03:50:30]Yeah, this flat part.

[03:50:34]Um, on X2 things start to increase gets interesting. It's one, two, three, two, one.

[03:50:49]Uh, X3 I think starts to get to be uh what is X3?

[03:51:02]Length one. X3 is one plus uh X2 is 3, X3 is three.

[03:51:12]on the next one.

[03:51:19]That's length three and length five it's also x3 is four x x3 at length three I think it's three interesting Um okay.

[03:51:58]And then X4 becomes 13531 and then starts to repeat.

[03:52:32]Oh, this is incorrect.

[03:52:35]This is a two.

[03:52:47]Uh, something's wrong here.

[03:52:52]Okay, we got one, two, three, four, five, six, seven, eight, nine. Okay. Um, this last one should be all once.

[03:53:05]Actually, I think these are Yeah, something like this.

[03:53:17]X1 is all twos.

[03:53:21]Yeah, I think X1's all twos.

[03:53:25]That means the this one's all twos also.

[03:53:29]And what about this one?

[03:53:32]These should mirror each other. X X2 and X6 mirror each other.

[03:53:40]So that's a bit odd, right? I mean, that's quite quite the pattern going on there. So um is this correct is the question.

[03:53:54]Let me try to double check this. So select one.

[03:54:02]It's one one one or no.

[03:54:12]One, two, three, four, five, six, seven, eight, nine.

[03:54:22]Length three. It's one, two, three, three, three, three, three, two, one.

[03:54:36]Length five. One, two, three, four, five, four, three, two, one.

[03:54:50]One, two, three, four, five, six, seven, eight, nine.

[03:54:57]And then this repeats, right?

[03:55:20]Okay.

[03:55:22]And then if we add those down, you get one, two, three, four, five, 1, 2, 2,2, 3, 1, 1, 3, 3, 3, 3, 1, 1, 1, 3, 4, 3, 1, 1, 3, 5, 3, 1, 1, 3, 4, 3, 1, 1, 3, 3, 2, 3, 1, and 1, 2, 2, Okay, that's the pattern. Um, now how can I compute that a little bit more directly?

[03:56:03]Right, if that makes sense. Um, how could I uh, excuse me, way too far down. Um, how can I encode this in a more generalized pattern is the question. Um I mean these ones are obviously just n each time the ending ones. The middle ones are a little more complex. It's two multiplied by across three multiplied across.

[03:56:48]But then there are these kind of it's sort of like this rising intersection that occurs.

[03:56:55]Um like what does the pattern look like for um 10 and 11 or just 11?

[03:57:23]So if we add in two more elements, right? Clearly we know what this these are going to look like.

[03:57:37]Um but it's less obvious what the internal parts going to look like. So this will probably be very similar, right? Add three there.

[03:57:49]This will go up to five and add five here.

[03:57:56]This will go up to seven.

[03:58:07]That's one, two, three, four, five, six, seven, eight, nine, 10, 11, 12, 13.

[03:58:14]That's too many.

[03:58:17]Um, hold on. One, two, three, four, five, 6, 7, 8, 9, 10, 11.

[03:58:32]Um, one, two, three, four, five, six, seven.

[03:58:44]I think this will go up to five.

[03:58:50]The reason why I think this caps out at five, um, two, three, four, five, six, seven, eight.

[03:59:01]Yeah. The reason why I think this just repeats at 11 is because like you add seven across. One, two, three, four, five, six, seven.

[03:59:17]You can only I think I think you cap out at like four or something here, right? So, one, two, three, four, five, six, seven.

[03:59:33]And then it'll be that one, two, three, four, five. Yeah, pickups out of five. I think I think it just repeats.

[03:59:56]Um, which is a little bit odd. I wasn't expecting that, but that's probably what happens.

[04:00:04]And and then these repetitive patterns repeat.

[04:00:30]That's probably what occurs.

[04:00:35]This one should be okay.

[04:00:47]So then these end up being a similar pattern that we saw before.

[04:00:53]Twos across, threes across, but then we have ones, threes, fours, threes, ones, and then ones, threes, fives, threes, and ones.

[04:01:06]It's a weird pattern. It's a weird pattern. Whatever I was doing before, I don't think captures this pattern, by the way. I don't think so.

[04:01:15]That is a strange pattern.

[04:01:19]I think this is the right one.

[04:01:37]Yeah, the cap is going to be the length minus whatever sequence you're working through.

[04:01:46]plus one um and and minimum of the length itself and then and then that difference that just described which is n minus length + one. So in this case it's three right 11 - 9 + 1 is three and then in this case three would be the minimum of those two and then these values are just going to rise up to that cap and then stay there and then and then fall back down. And that's the that's the clear pattern that every sequence is going to follow. Um but then I've got a sum in the other direction across those sequences.

[04:02:28]So even those those sequences have a very clear pattern, the sum across those sequences and the the cross-section of those sums of those sequences is not as obvious.

[04:02:40]So it kind of bubbles up. It's like uh repeated ones, then repeated twos, then repeated threes, then some one three repeated fours, and then back down 31, and then 13, five, 3, one, and then this this part just repeats a few times, this middle part.

[04:03:08]Um, and then and then you have the same sequence again. 1 3 4 3 1.

[04:03:16]So, a bit odd. A bit odd. Um, yeah.

[04:03:24]Interesting. Very interesting. Um, huh. Uh, I could take the previous value and and increment or decrement depending on where we're at. So, the first value starts off at n.

[04:03:49]The next value we add n minus2.

[04:03:53]The next value at n minus2 again.

[04:03:56]Then the next value um it's n minus4 gets added. Then n minus 4 gets added again.

[04:04:05]Then we repeat that value twice.

[04:04:08]Then we subtract n minus4 and then subtract um n minus 4 again. Then subtract n minus 2 and then subtract n minus two again.

[04:04:24]Okay.

[04:04:28]Interesting.

[04:04:30]So, what does that look like?

[04:04:40]There's three sections.

[04:04:46]The first section is going to be start off with n and we say okay um result plus equals um Let me uh let me put this up at the front so I can go back to my notes easily.

[04:05:28]Okay. Starts out n equals one. Now we're going to add n minus 2.

[04:05:42]Okay.

[04:05:45]Um, yeah. Add n minus two.

[04:05:50]Then we add n minus 2 again.

[04:06:10]Okay. Oh no. Um it's value time array of I array of zero.

[04:06:23]Then value times array of one.

[04:06:27]Um array of two. So we have n minus two.

[04:06:35]Then we add n minus 4.

[04:06:50]So add n minus two. Start off with n add n minus two.

[04:07:03]Add n minus two again.

[04:07:13]Add n minus4 here.

[04:07:17]Do that again.

[04:07:28]Then maintain that one two more times.

[04:07:49]Then subtract n - 2 n - 4 subtract what we just added and then subtract again.

[04:08:21]and then subtract n minus 2 and do that again.

[04:08:42]Uh, and that will give me zero through nine. It should be 10.

[04:08:53]Uh, one, two, three, four, five, six, seven, eight, nine, 10, 11. Should be 11 things I had here.

[04:09:01]um n. So we would do we would do n add n minus4 add n -4 or excuse me n minus two add n -2 add n -4 add n -4 leave it once leave it twice subtract n -4 subtract n -4 subtract um n minus 2 and then uh subtract n minus Um, one, two, three.

[04:09:53]Once. One, two, three, four, five, six, seven, eight, nine, 10.

[04:10:08]Um, I'm missing something here.

[04:10:17]So, start with n. That's once.

[04:10:20]Add one, add one, add one, add one. So it's + 1 + 2 + 3 + 4 5 6 subtract 1 7 subtract 2 8 subtract n subract 10 uh one two three four 5 6 7 8 9 10 0 1 2 3 4 Oh, that's what I'm stuck. I was going to say I was like, wait a minute.

[04:11:09]Should have this fully described here.

[04:11:14]Okay. Yeah, there we go. I was going to say I was like I think I did this right so far. So these are three different sections, right?

[04:11:22]This one is the increase or kind of increasing section and then this is like the decreasing section.

[04:11:31]Um yeah or non increasing.

[04:11:41]So not changing decreasing.

[04:11:51]Um this is for the n the n= 11 case. It looks like this.

[04:11:59]Excuse me. So let's try to emulate this now. Let's do val I Z start with I and then we're going to add equals and there's this other value J starts off at zero so at two and we're going to plus J plus equals two Um, we're going to do that. Um, it's actually going to be in steps.

[04:12:42]So, we actually repeat repeat J twice.

[04:12:48]Um, so we're going to say something like this.

[04:13:03]only when I is a certain value. So when I is even, we don't multiply by two.

[04:13:17]Um we could do two minus or something like that.

[04:13:33]Um, so if it's odd, um, how does this work? I might have to do the other way around. Something like this.

[04:13:47]But when it's uh when I is odd that's when we want to J starts off at two right yeah so initially we don't touch J we don't touch the value and then we add and then I should be even I I should be odd We're going to increment now.

[04:14:21]So that way when we iterate again um oh no no uh actually only when when it's when I is even again.

[04:14:38]So if I is even 0 - 2 I think it's supposed to be the other way around.

[04:14:54]When I is even, this will increment by two. When I is odd, this will increment by zero.

[04:15:02]Okay? And then, so what's going to happen is we get uh initially we decrement the value by two.

[04:15:14]Then um so it's just val of array of zero array of zero then decrement by two um because this is even or increment J by two no I I actually becomes odd after that so we don't increment increment J and then and And now when I is odd, we don't touch J.

[04:15:55]It's a bit confusing. It's a bit confusing.

[04:15:59]Uh let's do let's do it this way.

[04:16:01]Actually, this is a little bit easier to think about.

[04:16:07]There we go. Let's do it this way.

[04:16:10]It's confusing. You want to modify value first before I apply it. Let's do it that way. So initially uh val increments by n flatly and j is zero and then we're going to we modify i zero and then now here let's do j first and then increment i and we can say when i is odd when i is even then this will add two. Okay.

[04:16:49]So now we add two to J add N minus 2 I is now one. We do perform this routine done.

[04:17:01]Um now J doesn't change. I increments to two. Perform this routine. So we subtract two again from J. I is now even at uh three I think.

[04:17:20]Uh oh no no um at yeah when I is two before it increments we add this again we have four i is three. Okay so this this is this will work. Um but now we get to five. So that's when I is less than four, less than or equal to four, we want to do these routines.

[04:17:44]Um, what's interesting about this is we'll come back to that.

[04:17:57]There's now this next set of things which is I is greater than equal to five and I is less than or equal to six.

[04:18:12]Um increment I and just say result plus equals value times array of I.

[04:18:20]Right? That handles these cases.

[04:18:25]And then finally the mirrored version of this is going to be the decreasing part.

[04:18:39]I is greater than equal to 7 and I is less than equal to the array of size.

[04:18:54]So we're going to use this for the rest of the way.

[04:18:58]Um so now it's subtract n minus j and here um j starts off exactly where it was before at four.

[04:19:16]Um, and I at this point is seven and we would apply n minus 4 to seven and then j we want to increment now or decrement now actually um when i is seven this doesn't change. So yeah, this gets applied twice. Doesn't change until you see eight and then decrements again until you get to 9 10 and then we're done. And that's it.

[04:20:00]Um, and that works for the 11 case.

[04:20:03]That's exactly correct for the 11 11 case. I suspect this is correct for all the cases quite frankly.

[04:20:09]Um if I just modify I so here this went from 0 1 2 3 4 which is the fifth element um first five elements then we had two elements where it didn't change um and then the last I guess five elements or last four elements I suppose.

[04:20:41]Um, interesting.

[04:20:51]So, how do I know what this should be?

[04:20:54]Well, compared to 11, this is like 11 / two would be five. Be like less than 11 by two. Less than nid by two.

[04:21:06]and then be greater than or equal to n /2.

[04:21:11]Um I think this is only three elements quite frankly in the middle typically one to three elements.

[04:21:27]Um, let's look at 13 so I have an idea better sense of things. What happens with 13?

[04:21:47]What's chat doing?

[04:21:51]What's up, chat?

[04:21:54]What's up, chat? Uh, okay. 13 is going to be a copy of So here we'll add another two elements.

[04:22:04]By the way, I didn't cover what this looks like for the even cases. I think it's very similar.

[04:22:11]I suspect it's a very similar thing.

[04:22:15]For three, it's just going to be this.

[04:22:22]Actually, I should just copy this for this is going to be 11.

[04:22:29]What happened?

[04:22:34]Uh, I should probably just do that.

[04:22:41]Okay. Um, five. One, two, three, four, five. Five repeated.

[04:22:50]This will be the same for Seven or nine.

[04:22:55]And then seven is going to be 1, two, three, four, five, six, seven.

[04:23:05]Um, 64 32 8 9 10 11 12 13. Yeah. So this is going to be this this sequence. Um so again n minus 2 add n - 2 add n minus 2 again add n -4 add n -4 again and then add n - 6 add - 6 again n - 6 again and then you would have um ah okay I see the problem and then you would have um subtract n - 6 subtract n - 6 again etc. So actually there is no middle section. What happens is um this basically just uh becomes zero and and the n the j becomes equal to n.

[04:24:14]you just you're just subtracting uh you're just subtracting twice uh n minus n. That's what's going on here.

[04:24:23]So this is indeed um I of uh so in this case it would be 0 one two three or no no um it's going to be 0 one two three four five six I think all the way up to I equals um in fact I think you actually just go you're not subtracting n minus this thing anymore.

[04:25:11]I actually think I think this just goes all the way through.

[04:25:18]Yeah, I actually think this is just all the way through.

[04:25:36]I could be wrong about this, but this might just be all the way.

[04:25:44]It might just be that simple. I don't know.

[04:25:55]Oh, okay. Maybe not.

[04:26:00]Not quite. Uh, that's funny. Um, whoops.

[04:26:19]Uh oh.

[04:26:22]What did I do?

[04:26:26]Uhhuh.

[04:26:35]Interesting.

[04:26:39]Uhoh. Uhoh.

[04:26:50]Huh?

[04:26:52]What?

[04:26:54]Can make this a long long.

[04:27:08]I did something wrong.

[04:27:12]But it might just be that um this value starts to exceed N at some point like the J start to exceed N.

[04:27:22]And actually uh wait what what's going on here?

[04:27:46]Oh, not less than a repo. Duh. That's my fault.

[04:27:52]I was like, "Wait, I did something wrong here."

[04:27:55]150. That's not right.

[04:28:00]That's not right.

[04:28:03]These are way, way too large, huh?

[04:28:07]These are way too large.

[04:28:25]Um, Oh, it's not n, by the way. That's a mistake. It's It's n divided by two. 1 2 3 4 five 6 7.

[04:29:04]Yeah, it's like n plus one divided by two.

[04:29:09]And if it was 14, it would be two. Or no, if it was if length was if the if n was 14, it would still be seven. Length is 13, it's seven.

[04:29:26]Say add one by two and um say we'll just say odd odd lengths.

[04:29:58]That may have had something to do with it.

[04:30:04]Okay, it's closer. Uh, it's wrong in the even cases though.

[04:30:14]Whoops.

[04:30:18]uh in the even cases it's wrong.

[04:30:30]Let's do the fourth the four case.

[04:30:36]Okay.

[04:30:39]I was close, man. I was close.

[04:30:43]seem to have figured out the pattern when it's odd at least.

[04:30:48]All right, let's go even. So in the four case, length one and three.

[04:31:05]I think it's just this um you sum all four and the three case it looks like this.

[04:31:21]Yeah, that's a little different.

[04:31:30]Uhhuh.

[04:31:36]It is different.

[04:31:40]Give it one moment.

[04:31:51]Okay.

[04:31:54]All right. Um the even cases are different.

[04:32:04]That was so close, man. That was so close.

[04:32:13]Okay. All right. Length one, length five.

[04:32:19]This is if you have six.

[04:32:28]Okay.

[04:32:32]That's one, two, three, two, one.

[04:32:48]Uh, all right. Definitely one, two, three.

[04:32:55]So the third value one the first one two three has the third value in it. Second one has the third value on it and the third one has the third value and then it it's kept at three. So it's repeats and this one is so that pattern I just showed you is only for the that's only for Hi. What's up uh Yashinda? Oops. Hope your day is going well. Welcome welcome howdy. So we're investigating right now how I could solve this question sum of all oddlength subarrays um in linear time but also linear memory meaning we're going to do it without using dynamic programming and I think there's a way to do it but I've been struggling to get it right. So I think I got the odd case. Um but I don't think I got the uh the even when you have an even number of elements.

[04:33:56]Looks like the odd case is right, but the even case is is not doesn't work the same way. So I'm investigating the pattern for the even case. See if I can find out what that pattern is.

[04:34:09]using pattern recognition. Pattern recognition to see uh if I can figure out what the pattern is for uh for the even case.

[04:34:20]All right, here we go. So in the even case, four elements. This is more of what what the pattern looks like. We add this is like if it was X0 I probably should put that at the top actually. So used to doing at the bottom. I don't I don't typically use Excal for my notes. I use a different program. Typically, I should write a notes program or something. Just write something for myself. That way, I just always have it available.

[04:34:47]I could open source it and then people can use it. It's like notepad, I guess, but more for my use cases, I guess. I don't know. Sky Draw is pretty good, though.

[04:35:00]Just isn't quite what I want to. It doesn't quite flow the way I'd like it to flow, I guess. I don't know. like it adapts to it. Um anyway, but so if this was like x0, x1, x2, x3, right? When we're looking at length one subarrays, we would be adding each of these one time, right? So one, one, two, three, four.

[04:35:27]But for length three subarrays, we'd add one, two, three here. And then we're adding one, two, three there. So we would have this one twice and this one twice. That's why I have one, two, two.

[04:35:43]This pattern is not the same as the odd pattern that I had before. The odd pattern that I had before is a little different.

[04:35:50]Um, in the case of six elements, the pattern looks more like this. So in the odd case, so the odd the first one length one, length three, we would have one, two, three, back down to 3, two, one, and then length five actually repeats that um it would be length five, one, two, three, four, five, and then one, two, three, four, five.

[04:36:22]Uh, it actually is not this pattern.

[04:36:26]This is wrong. It's this pattern.

[04:36:30]That was wrong. Um, one, two, three here. One, two, three here. So, X1 has two. And then one, two, three again. X2 has three, but also X3 has three because it's at the tail end of this one. And it's in the middle of this one.

[04:36:49]And then X4. Similarly, it's included here and it's included here and nowhere else.

[04:36:58]So, actually the pattern a little more complex little more complex than the other pattern.

[04:37:06]So, I got to figure out what that pattern is. So, I think what I can do is say do the following.

[04:37:15]Don't need this.

[04:37:19]This doesn't need to be a long long. I thought it needed to be because I was accident I I made a mistake and I was I was um I made a mistake and I was adding uh like uninitialized memory with this with an equals there which is bad. Um but this is going to be if uh array size and one Then we're going to do this.

[04:37:57]Um otherwise we're going to do a different pattern.

[04:38:05]In the even case pattern looks a little more complex. So it looks like it look let me also check the stream health just to make sure stream is okay. Um looks all right.

[04:38:22]All right. Um in the even case it looks like I start with n similar to the previous uh pattern where n is uh I say n but it's it's really this odd lengths value which I think is the same. So when n is when n when the size is four size is four divide by add one divide by two and you get two. When size is six add one divid by two you still get three. Yeah it's fine. So I get that's this is the right odd lengths amount. So we start by adding odd lengths which is fine.

[04:39:06]But then we add it looks like odd lengths minus one rather than minus two.

[04:39:14]Okay.

[04:39:18]Yeah.

[04:39:21]So J + equals 1 rather than two.

[04:39:35]And And then oops.

[04:39:44]Oh.

[04:39:47]Um, looks like we subtract one initially and then I think we subtract one again from J.

[04:40:03]Uh, yeah. Which There's the one there.

[04:40:10]And subtract another one because we're only going to improve here.

[04:40:15]Um, and then subtract another one to Yeah. And then just keep subtracting.

[04:40:23]So, just subtract one the whole way through. Uh, okay.

[04:40:32]I don't know about that one, but I try that.

[04:40:36]It doesn't seem correct. Oh, that's right. Okay. There you go.

[04:40:45]There you go. There's your pattern.

[04:40:47]Tada. I did it. Tada. All right. I'm going to go for it. That's probably correct if it works on those cases.

[04:40:54]Hey, there we go. Beautiful. I like that. How you like that? Hey, we did it.

[04:41:00]Spent hours on that. Oh my gosh. Oh, so unnecessary. But there you go. They asked for a linear time solution. So, we got linear time and no extra memory.

[04:41:15]Tada. Tada.

[04:41:21]That was a little gross. That was a little gross. I wouldn't recommend that.

[04:41:26]That's like This is like when you want to do research, this is the kind of thing you do. You just tinker with stuff until you find a pattern that you can exploit.

[04:41:36]That's how you do research, man. That's how how it works.

[04:41:43]Tinkering until you find exploitable pattern, which doesn't sound great when you phrase it that way, but say a useful pattern. Exploitable pattern.

[04:41:56]Exploitation. Um, no.

[04:42:01]Uh yeah. Okay. It's just satisfying to submit it a bunch of times. I spent so much time on that. It was so unnecessary to spend so much time.

[04:42:10]It was interesting though. I mean, we learned something. I don't know what we learned exactly. We learned that uh yes, this does have a pattern. Yes, that can be useful. Yes, it can be done in in linear time. Yes, it can be done without with constant extra memory. Uh yes, it's a bit complicated.

[04:42:29]Yes, it does simplify to something that's actually not too bad. Um, and yes, it will take basically research time to figure all that out. Uh, I don't know how valuable all that information is, but uh I guess it's something. I don't know. I don't know what to say, man. I don't know what to say about this, man.

[04:42:49]Um, that was fun. I guess that was fun.

[04:42:53]That's how I got there.

[04:42:55]Sweet. I don't know. What do I do now? I just keep going. Um, I feel like I should take a break. Oh, how's the stream doing? Stream is Let's see. Is it still live? Stream might not up anymore. I feel like I should take a break. Oh, how's the stream doing? Stream is I think it says the stream is um Okay, there we go. It's back. I was going to say it says the stream is uh post buffering. Um, so there we go. We got the got that answer, man. Got there.

[04:43:32]Do one more.

[04:43:35]Oh, satisfying. Very satisfying. Um, okay.

[04:43:40]Wasn't really necessary to do all that, but we we we did it. We did it. We did it. Uh, all right.

[04:43:50]Okay.

[04:43:52]We'll do one more question, I think, and then maybe I'll take a break. I was going to do an eight hour stream, but I I kind of like I don't know, man. That was that was a bit much. That was a bit much. Let's do one more and I'll think about what to do after that. Zero index integer array nums of length n integer k return the number of pairs uh 0 less than equal to i less than j less than n such that nums of i equals nums of j and i * j is divisible by k.

[04:44:21]Okay. the number of pairs. That's my All right.

[04:44:29]Okay. Well, this isn't that hard, right?

[04:44:32]Um, basically, uh, any number that's divisible by K, all of the numbers to the right um, can be paired off with K.

[04:44:51]And you can do left to right. So you don't need to go backwards at all. Um, yeah. So that's that's the easiest way to do that.

[04:45:04]So you can just do something like the following.

[04:45:21]Um, it's going to be nums of i mod k 0 times uh nums size minus i possibly plus one something like this.

[04:45:39]Um like if you pick the third if you pick the let's say the first element it's going to be paired up with every other element uh except for itself right oh wait oh nums of i equals nums of j oh hold on a second oh no that's a little bit different um never mind so I did that All right.

[04:46:17]Okay.

[04:46:20]How big are these numbers? Oh, it's a little bit. It's a different approach I need to take. Okay, they're between less than 100. So, I can use a frequency map.

[04:46:28]We're going to use a frequency map to do this. I did this. I got the wrong answer. Sorry about that. I misunderstood.

[04:46:36]I misunderstood.

[04:46:40]Um we'll come back to that explain.

[04:46:45]All right. Uh actually it's a little different. So frequency of I nums of I and it's actually going to be nums of I mod K= 0 times might be a little bit easier actually I think it's this one is the way to do it. This is a bit of an odd problem.

[04:47:19]Wrong. Okay. I misunderstood.

[04:47:23]This one's correct. It's wrong.

[04:47:31]A2.

[04:47:33]So it has to be Yeah. So basically I'm looking at the values previously. So when I see three and three that should be one saying expected four. when I see one and one um that's not divisible by two, two and two. So the first two there aren't any previously so we add zero. This two and two we should add one and then this two and two we should add two.

[04:48:09]Um, so it should be 1 plus 2 plus 3.

[04:48:19]Uh, why am I getting the wrong answer?

[04:48:23]Shouldn't I get the right answer?

[04:48:25]Shouldn't this give me four?

[04:48:29]Um frequency of nums of I which should be say when you see two it should be zero when you see the next two there should be a one there. So you add one and then frequency becomes two. See this you add another two and this adds zero. This adds one.

[04:49:11]Yeah, it should be four. I get three.

[04:49:17]Unless there's something going on here.

[04:49:18]I don't realize what what's going on here.

[04:49:43]What's going on here?

[04:49:54]So it should be 0 0 1 3.

[04:50:00]Okay, that's good. 1 three and then 0 0 1 3 3 4.

[04:50:14]Oh, those aren't divisible by two either.

[04:50:22]Oh.

[04:50:27]Oh, why is this four Wait, what?

[04:50:59]Four pairs.

[04:51:03]Oh, if it's zero. Wait, what?

[04:51:15]Oh, I'm sorry. That's I think I do need to take a break.

[04:51:25]My brain, dude.

[04:51:28]My brain, man.

[04:51:32]Oh my gosh.

[04:51:36]Oh my goodness. I didn't even realize it's I time I times J is okay. Oh boy.

[04:51:45]Yeah, I need a break. I need a break.

[04:51:49]It's a mixture of going too quickly and also not uh really thinking it through, reading it, reading the problem. It's good to solve the actual problem that's being asked. Oh my god.

[04:52:03]Uh yeah. Okay. Uh, interesting.

[04:52:11]This actually is pretty close, but it's um, okay, I think I could still use a frequency map. Frequency map, but I need I times J is divisible by K.

[04:52:30]So, as long as one of these is to this one by K.

[04:52:41]Yeah, it doesn't matter if they're Yeah, actually it's just I mod K.

[04:52:52]I think one small change and this works.

[04:53:03]Maybe this actually might be that simple of a change.

[04:53:08]No.

[04:53:11]Nope.

[04:53:16]Not what I expected for.

[04:53:21]Um, no.

[04:53:28]Nope.

[04:53:30]Okay.

[04:53:33]Uh, interesting.

[04:53:38]Doesn't quite work like that, unfortunately.

[04:53:45]Yeah. The problem with this is that uh no, this approach doesn't really work in this case. It's wrong because I've already passed three like it this three could be paired up with all the other threes.

[04:54:11]um could do it a different way. How about I just take all the ones that are um I could maybe do two passes.

[04:54:32]Um I mean Uh I'm wondering if I could do a double pass.

[04:55:11]Well, I mean, I could double count all the pairs, right? I could do I, J, and JI.

[04:55:20]Um, if I just count all of the if I get just get the frequency of of values, for example, the frequency of two is a three. And then I just say um oh no it's not it's not yeah let's just get the frequency of all these values right and then I go left to right for each value that's divisible by k I pair that off with all the other ones so you know 2 minus one be one and then when I went over this way um I wouldn't count it again.

[04:56:03]No, that's not correct.

[04:56:07]Excuse me. That's not correct.

[04:56:13]I'd have to get the frequency of things that are divisible by K and things that are not divisible by K or the indices are divisible, the indices are not. Um because it's going to be the indices that are divisible.

[04:56:32]I would do um like two choose those indices and then the indices that are not divisible uh I would need to pair them off which I would do a I would just multiply those two.

[04:56:56]Yeah.

[04:56:59]Okay. That's fine. That works too.

[04:57:03]Uh, okay. Frequency divis frequency divisible and not frequency.

[04:57:24]Let's go with this one.

[04:57:40]I can make these static. Static.

[04:57:45]I don't know if that really matters, but we're going to do that anyway.

[04:57:49]So for each number we're going to say frequency divisible const check is I mod k= z and then we're going to say frequency of nums of i.

[04:58:10]Let's see. Let's check it's divisible.

[04:58:19]Not minus equals check or plus equals check. It's not or not check.

[04:58:26]Um and then we're going to say for in zero less than 100.

[04:58:37]um results plus equals uh I mod. So again, cost check.

[04:58:49]Um I mod.

[04:58:53]Oh no, that doesn't matter.

[04:58:58]Frequency of divisible I times frequency I + one shift one. So pair those off and then the other one will not be paired. Just multiply.

[04:59:22]I think that's it. Something like that.

[04:59:23]I'm going to go for that. See how that goes.

[04:59:26]Hey bro, how are you? What's up? Devote of Radarani.

[04:59:30]Welcome. Howdy. Hello. Hello. Doing well man. Thank you for asking. Doing some lee code over here. Apparently getting it wrong though.

[04:59:39]No.

[04:59:44]Oh no. What did I do?

[04:59:48]What happened here? Uh oh. Uhhuh.

[04:59:54]Wow. Um, interesting.

[05:00:02]Uh, I don't know what I did wrong. Uh oh.

[05:00:09]Uh oh. Oh, I might have been in choose too. I might have not. Yeah, that's a mistake. That might have been the mistake.

[05:00:18]There we go. Got it. Okay, I think that's it. I'm going to submit this one.

[05:00:24]That's a relatively efficient solution.

[05:00:27]It's an okay one.

[05:00:30]Oh, what's wrong, though?

[05:00:35]No.

[05:00:37]Oh man, that's a bummer. All right.

[05:00:41]Almost efficient and wrong. And wrong. It's always good.

[05:00:49]Oh boy. Oh boy.

[05:00:53]Tisk. Tisk. Tisk.

[05:00:56]Uh.

[05:00:58]Okay. Let's see.

[05:01:00]Huh. Output five expected eight.

[05:01:04]Interesting.

[05:01:08]All right, let's see if we can get those pairs. Um, now mind you, this could be done in quadratic time efficiently because there's only 100 question 100 uh integers, but part of me thinks this could be done with a frequency map uh a little bit faster. So that's why I'm trying to do that. But uh 0 1 2 3 4 5 6 7 8 9 10 11 12 13 elements. 1 2 3 4 5 6 7 8 9 10 11 12 13. 13 elements means there's only three elements here that are divisible by four.

[05:01:53]Three indices, but they can be paired off with quite a few other things. But there's only one nine and one other nine.

[05:02:00]So two nines.

[05:02:02]Um which the second nine the second nine is actually in the uh in the no zero one two three four zero one two three four and the second is not. So I pair those two off. That gives me um one pair.

[05:02:25]It says they're looking for eight pairs.

[05:02:30]Four, five, six, seven, eight. Okay, this three could be paired off with one, two, three, four things.

[05:02:39]uh I would get 1 + 3 is four and then one more would give me five which is 0 1 2 3 4 5 6 7 8 9 10 11 12 There's nothing to be paired off with a one.

[05:02:59]There's only one one here.

[05:03:04]I * J is by K has zero indexed.

[05:03:13]Huh? 0 1 2 3 4 nine. Only one of the nine.

[05:03:21]So that's a and that happens to be a pair. That's a pair. Then there's one, two, three, four threes.

[05:03:31]012 two three four five Oh, I did it wrong.

[05:03:41]Oh, I did it wrong.

[05:03:44]I didn't think about um when K itself has divisor and you multiply I and J together and it's divisible.

[05:03:54]I thought I could just Ah, that's a mistake on my part. Yeah, there more pairs.

[05:04:01]Also, my calculation was wrong anyway.

[05:04:03]Um, somehow it shouldn't have been. Oh, I guess it was five. I guess zero, one, two, three, four, five, six, seven, eight, nine.

[05:04:15]I think the eight here we get one, two, three.

[05:04:26]I don't know why I got five. I think I was supposed to only get four there. But anyway, I don't think my algorithm was correct.

[05:04:34]Like I don't think my implementation of what I was trying to do is correct anyway. But also, uh, I did not consider when K is a composite.

[05:04:46]That's a mistake on my part.

[05:04:48]That's a mistake on my part. Um, okay.

[05:04:56]Uh, I mean, yeah, that's that's a tricky one.

[05:05:09]All right, we're just gonna we're just going to go with the the normal. I don't I don't think it's that obvious whether or not this has a faster approach. That was a mistake on my part. We're just going to go with the standard approach.

[05:05:25]straightforward approach.

[05:05:30]Um Yeah, given the constraints, this is fine.

[05:06:04]Um, I think this will work. I might need some need some things in here.

[05:06:11]Okay, what? Um, I would put these in here just to clarify things.

[05:06:19]Yeah. Uh, given the constraints, this works. But if it was if the constraints were a little more complex, then this may not work so well.

[05:06:30]Dang, man. Dang.

[05:06:33]Yeah. All right. I said I was going to take a break after this, but that that kind of I'm not so sure about about this one. Let's see.

[05:06:46]Um, okay. Yeah, I think uh I think uh I just kind of feel bad now.

[05:07:02]Feel bad for trying to get the get a a better solution that was probably not correct. Uh it's awkward. Um, I mean, okay, you know, all right, given the constraints, this is this is a reasonable solution. So, we'll go we'll go with the next question. We'll go one more. We'll go one more. Um, and then I think I'll take a break.

[05:07:27]That one wasn't too satisfying.

[05:07:30]Yeah, it was a bummer. Not a bummer, but like not great that I uh submitted an incorrect solution there. There was a biker going on a road trip. The road trip consists of n plus1 points at different altitudes. The biker starts his trip on point zero with altitude equal to zero. Uh you given integer array gain of length n where gain of i is the net gain and altitude between points i and i + 1 for all zero less than equal to i less than n. Return the highest altitude of a point.

[05:07:59]Okay. Uh going on trip road trip consist of some points at different altitudes.

[05:08:06]It's true at point zero altitudes equals zero. Integer array gain of length M gain is the net gain altitude between points I and I + one. Okay, the highest altitude.

[05:08:20]Um I'm not sure if we can do this in better than linear time.

[05:08:29]Yeah, I think this is just we'll see.

[05:08:58]I don't know. I think this is probably a relatively straightforward thing.

[05:09:04]Is this I don't know. This is all I need.

[05:09:09]I'm not sure if this is what they're looking for.

[05:09:13]Just pretty simple.

[05:09:16]Maybe this could be done like in simpler way, but I don't or a more um what do they call that?

[05:09:27]Could be done in a more concise way. I don't know.

[05:09:31]Um I mean, all right.

[05:09:38]Okay, that one. I don't know what to say about that one, man. I don't know. That one's definitely a little bit easier. Well, these are all relatively easy. I think depends on how you try to solve them, right?

[05:09:51]Positive integer n. Find the pivot integer x such that the sum of all elements between one and x inclusively equals the sum of all elements between x and n inclusively.

[05:10:02]Uh interesting. So basically the the left side and the right side but not it's not pivot integer. It's um I think or it's not the left side the right side or equal. It's the I think it's every element that's smaller.

[05:10:21]Unless X is an index. n is eight up six.

[05:10:25]Oh no.

[05:10:27]Oh excuse me. Oh I see. Oh, interesting.

[05:10:33]I think you can figure out this uh mathematically at most one pivot.

[05:10:42]Okay. Um Oh, interesting. Okay.

[05:10:51]So, this is a math thing, I think. Um, if you do, uh, let's just make sure the stream is still live. It's okay. Yeah. Okay. Um, so, so this would be one to n, right?

[05:11:11]Uh, we're going to say one to x x + one to n. They should be equal to each other.

[05:11:25]um more precise notational I'll put down in a second but it's okay equals x10 inclusively okay so it's going to be it's not x plus one it's inclusive both sides so this is kind of like uh sum I actually didn't realize that one x is sum of x to n which this sum is sum is um is x * x + 1 / 2. And that's going to be the sum n * n + one / 2 minus the sum from 1 one to n minus the sum from 1 to x - one which is x -1 * x / 2.

[05:12:24]So that gives you um x * x + 1 / 2 plus uh x * x -1 / 2 = n * n + 1 2 can multiply everything by two to get x * x + 1 + x * x -1 nus this one. That gives you x uh * x + one plus um x - one n * x - 1.

[05:13:09]That gives you x * uh 2x = n * 1.

[05:13:18]Um, which then gives you x = x^2 * x^2 + 1 x is =<unk> of n * n + one.

[05:13:44]Yeah.

[05:13:46]Um okay.

[05:13:56]Turn static cast int square root and one.

[05:14:14]basically that um there might be I think yeah it should be a negative one in some cases though um it's not that easy to check if a number is a perfect square however um Um, probably the easiest way to do this is in salt.

[05:15:12]So we have this number and then we say um 2 * result times result equals um n times one say if bit shift if and this is equal or it's not equal.

[05:15:49]Otherwise returns.

[05:15:52]There we go. Simple.

[05:15:58]There we go. I think that works.

[05:16:06]Yeah. So, that's not a bad one either.

[05:16:08]I'm not sure it's exactly constant time, but it's it's relatively efficient.

[05:16:14]It's a relatively efficient solution.

[05:16:16]That's probably a good one to end end on for the take oh, not end on, but take a break. Um I was going to go I was going to go for a full eight hours, but um some of those questions took a really long time.

[05:16:34]Delete node a link list. This is a complex one or involved one. Um, this one is I already solved it, so I'm not going to do it again. But this is one of those questions that um it's kind of involved.

[05:16:54]Um, okay. They said it's not going to be a tail node and so you can so about two million accepted. Holy smokes.

[05:17:09]Oh gosh, it's a lot of a lot of people.

[05:17:10]Holy Jesus. Holy smokes.

[05:17:14]That's a lot of people.

[05:17:17]All right. Uh given the node to be deleted cannot be given access to the first node ahead.

[05:17:24]All the values link list are unique.

[05:17:26]Given node node is not the last node to link the given node do not mean or mean removing it from memory should not exist in link list number of nodes link list should decreased by one all the values before node should be in the same order input we should provide the entire link list head and the node to be given node node should not be the last node in the list it should be an actual node in the list build the link list and pass the node to your function And the output will be the entire list after the function.

[05:18:07]Um unfortunately uh you need the the node in front of this one, the previous node to do this efficiently. Otherwise, you basically need to like traverse the the list until you find your node, which is kind of a bummer, but it's not the worst thing in the world. Um, yeah. And then you just do a normal delete, which is basically just put the uh the previous nodes next um pointer to the deleting nodes next.

[05:18:51]little bit involved but not the worst. And then and then you want to take that node and then point it to some point it to a null pointer and then delete it. Delete it from remove from memory. Um but do you get the head node?

[05:19:09]You will not be given access the first node of head.

[05:19:20]What?

[05:19:23]Somehow I already solved this. I don't know.

[05:19:29]Oh, I see.

[05:19:37]Uh, interesting.

[05:19:42]Well, I mean the other way of doing this, which is a bit wonky, but you can is um so the node that you want to delete, let's say it's five, you could just take all the values that come after it and just shift them over.

[05:20:02]I wouldn't recommend doing and then just delete the last node, the the tail. Oh, that's why it's not it's not going to be a tail node.

[05:20:10]is because you wouldn't be able to delete the tail.

[05:20:15]So, you could do that, too. I mean, that's a bit awkward and weird, but yeah, you could do that. You can just cycle all the values back and then delete the tail node.

[05:20:26]It's kind of obnoxious, but yeah, it's fine.

[05:20:41]And then and then the tail node you can delete the memory. So yeah, I don't know how I solved this in the past.

[05:20:48]probably I did in Python in March, but uh oh to 2019 some time ago.

[05:21:02]I think I basically I suspect I may have cheated.

[05:21:08]Oh no, no, I did exactly that. I uh Oh, wait.

[05:21:17]What did I do?

[05:21:22]I don't even remember doing this.

[05:21:25]I said the node value is going to be next. Next, and then the node next.

[05:21:34]Oh, that's clever. Oh.

[05:21:39]Oh, I see what I did.

[05:21:43]No, man. Don't cycle all the values.

[05:21:46]Just just move the value. Oh, that's smart. So, just take the next node's value, save it in this node, and delete the next node.

[05:21:58]Ah, that's funny. I didn't even think of that. That's even better.

[05:22:03]Oh jeez.

[05:22:06]There you go.

[05:22:08]That's a fun one. Okay, so that's that one.

[05:22:11]That's kind of goofy, but yeah, it's okay. Don't No, don't cycle all the other values back. Just just save the value that's next to it and then delete that node.

[05:22:22]Uh, it's funny. Okay, got it. Got it.

[05:22:25]We'll do one more one more question then we'll then we'll take a break.

[05:22:30]All right. Arithmetic subarrays. A sequence of numbers is called arithmetic if it consists of at least two elements and the difference between every two consecutive elements is the same. More formally, a sequence S is arithmetic if and only if S of I + 1 - S I is equal to S sub 1 - S0 for all n I. Okay, arithmetic sequences. All right, these are arithmetic sequences. The following sequences, not arithmetic. You're given an array of n integers, nums and two arrays of m integers each l and r presenting the m range queries for the i queries. The range in the range l all the arrays of zero are zero indexed return a list of boolean elements answer where answer y is true if the subarray nums of l i l i + one etc can be rearranged to form an arithmetic sequence and false elements that's confusing um what are the bounds in this uh n numbers m is length m r length five n is 500. M is 500. Ly R Y is less than N numbers between 10,000 10,000 100,000 100,000. Um I don't know what I'm even looking at here. Uh uh arithmetic consists of at least two elements. Okay, got that.

[05:23:58]Um so these are sequences array of integers and two arrays of M and M integers each L and R the M range queries.

[05:24:09]Okay, so we got range queries. I query that range. All the arrays are zero indexed. Return a list of boolean elements answer or answer Y is true if the subarray nums L Y to nums R Y can be rearranged to form an arithmetic sequence and false.

[05:24:32]Okay. Well, that's peculiar, huh? Um I mean probably the easiest thing is to sort it and then check the sequence directly.

[05:24:44]Um there might be a more efficient way to do this but that's like the simplest way to do this.

[05:24:57]Give me 654 to the sequence.

[05:25:04]4569 cannot 3579 can be arranged.

[05:25:17]Huh.

[05:25:28]Um, I don't know if there's a more efficient way to do this. This is a bit bit of a complex kind of a thing task to do. Um, you maybe can use like a square root decomposition. Throw that somewhere in here to make things more efficient. I'm not sure where exactly or how, but that's like my best guess is that uh maybe a square root demp somewhere in here and then otherwise um I wouldn't really know how exactly and then maybe using hashmaps or something but probably the simplest approach is just for each query sort that range and then um check if that's an arithmetic sequence and time linear of the range.

[05:26:27]That's probably the simplest way to do it. Um the number of queries is uh only about 500 queries. The number of numbers is uh only about 500 numbers. So 500 squared is manageable. So we'll just we'll just go with that. We'll just keep it simple and go with that. Um I think doing something beyond that it's unnecessary for the constraints. It's also like might be really complicated if it's even possible. Um yeah I think the other the other question that I was working on where I was like oh I'm not really sure how I could do this.

[05:27:13]Everything you work on probably could throw a square root decomp in there somewhere, but the simplest thing is probably just um copying the numbers and sorting them. Um so int i zus i constant um left i.

[05:27:39]write is ry um then we'll just say sto vector inte of nums begin left nin right sort in uh we'll just say is arithic take vector say if need signs This two false um constant diff it's going to be uh v1 z i z. It really should be i is one. I is less than um i + one is less than size.

[05:29:07]true.

[05:29:09]Um if v of i + 1 minus d of i yeah uh is not equal to diff.

[05:29:30]Okay. Um vector B result of it's going to be L size and just say result equals this arithmetic.

[05:30:09]In this case, I just copy paste just copied the the vector into a into a sub sub vector and then sorted it. I checked it that way.

[05:30:21]It's so wrong. It's so wrong.

[05:30:28]Um 0 to two should be true. Four five six is true.

[05:30:36]Um 0 to three. 0 1 2 3 4 5 69 should be false. I got true for some reason.

[05:30:48]Uh this might be a plus one over here.

[05:30:55]And I might have made a mistake on that.

[05:31:03]Uh should be true at the end. I got false.

[05:31:09]012 345 3579.

[05:31:15]Um, hold on.

[05:31:32]What is going on here?

[05:31:37]Hold on.

[05:31:44]Six, five, and three. Um, wrong.

[05:31:48]It should be five, nine, and seven.

[05:31:57]Okay, let's try that again.

[05:32:08]Okay, good. So, at least I have the right things. Then uh 012 35 79.

[05:32:43]Oh, it should be front, not from. All right. Um 25 one two should be five to seven and should be four to five and four to nine.

[05:33:02]Yeah. Okay, that's right. I don't know.

[05:33:04]Uh, what happened?

[05:33:16]Oh, that's my gosh, man.

[05:33:23]I didn't even realize I did that. That was a typo. Okay. Looking at it like, wait a minute. Didn't I do this right?

[05:33:29]What did I do?

[05:33:32]All right. Um, no more debug.

[05:33:36]I'm gonna go for it. See how it See how it works.

[05:33:40]We're gonna go for There we go.

[05:33:44]Beautiful.

[05:33:46]Beautiful. Not the fastest solution, but like reasonable reasonable time to solve it. I probably should have solved it a little bit faster. Let's see. Let's see what the fastest solutions look like.

[05:34:01]I'm curious.

[05:34:04]I am curious.

[05:34:07]Let's see.

[05:34:15]Okay. Interesting.

[05:34:19]So, they wrote a check. They said, "All right, for each query, we're going to do a check." Okay, fine. That's fair.

[05:34:27]Um then the check is the length, min value, max value. Okay, for each of these.

[05:34:44]So it does do a linear time search over the numbers.

[05:34:50]It's a min value and a max value.

[05:34:54]does a check to see if the the does a modulate. So terminate early check then it gets the difference d return true another terminate early check visit.

[05:35:13]So it it does loop directly through um and get this norm.

[05:35:27]Oh, I see. Oh, interesting. So it create they created so it did do it in linear time. Okay, it's faster. Yeah.

[05:35:35]So what they did was um basically create a um a vector booleans that checks whether or not a particular number has been visited yet. Um and they actually used the norm which would be they normalize the values.

[05:36:04]So the arithmetic sequences aren't that large. Um which means that the set can be kind of small on the smaller side.

[05:36:16]Um it's actually the number of arithmetic values that larger. Okay, that's a clever way to do it. So it's this is kind of like linear time. I would say linear time um to process those numbers. But the basic idea would be um okay so you could normalize using the minimum value.

[05:36:48]you could take the difference between um I think the way they did it was that you take the difference between the your current value and the nor and the minimum value and then you divide by the the the differential and that's going to give you a normalized value which basically tells you how many times you added B to get to that point. So every element in that arithmetic sequence is going to have sort of a unique normalized value. Um and pretty much if there's a repeat of any normalized values, then you return false. Or if any of those values are not normal, cannot be normalized. In other words, if you divide by D and you get something that's a remainder, then you also return false. So, an arithmetic sequence is going to have every one of those normalized values represented exactly once.

[05:37:52]Uh, that's pretty interesting way of doing it. I like that. I didn't think of that.

[05:37:58]Um, that's makes it that's a lot faster.

[05:38:02]Excuse me. It's pretty good. It's clever.

[05:38:06]I was thinking that like there's maybe some way to do this, but I couldn't I couldn't I didn't think of it um quickly.

[05:38:14]But yeah, using a um it's not really a frequency map. It's more of just a it's not exactly a set either. It's if you normalize the values and then use a uh a vector booleans, you can check um that those normalized values don't don't appear more than once and that all the values can be normalized. That's a clever clever approach. I like that. Um, okay. So, let me let me take a break.

[05:38:43]Um, it's been almost 6 hours here. Also, let me see.

[05:38:50]Clever approach. I like that. Um, okay.

[05:38:54]So, um, it's been almost six hours here.

[05:38:59]Yeah, I'm just looking to see if the stream probably the stream's not getting enough data buffering. Um, it's buffering now. All right, let me wait for it to stop buffering before I stop. Uh, that's an interesting question. I mean, that's all right, I suppose.

[05:39:22]So, yeah. Thank you all for watching.

[05:39:24]Um, I'm going to get going. I think I'm not going to leave. I think I'm just going to take a break for a little bit and then go do some other things. Uh, okay. The stream is come back now. It's all right. It's good.

[05:39:41]It's a bit of a a grind so far. Um, yeah. All right, let me stop here. I'm gonna stop here and then I think I'll go ahead and uh take a break for a few hours, maybe an hour or two, and then come back and do a few more hours. I'll try to do like I was thinking I want to do like eight hours today, but that would be cool. So, yeah. Thank you again for watching, hanging out, saying hello. I appreciate it. Um, let me uh I think yeah, I think I'll just stop here. Just stop. If you like the stream, don't forget to follow uh like the video, all that stuff. and uh or to subscribe.