ET Revision Session

Added: 2026-05-10

[00:00:00]Which option will be true? Which thing will be printed?

[00:00:11]Anyone?

[00:00:19]D. Why do you think B D will be printed?

[00:00:26]Any of you can explain why do you think uh option D is correct.

[00:00:40]>> So because none zero all these are falsy values.

[00:00:44]>> Yeah. So if we use none zero or an empty string if we convert them to boolean we will always get false. So for these we are getting false for these we are getting false and uh else is basically saying that if true so if true is true so we are printing this thing so that's why option D is correct okay no doubt in this one right okay so let's move to the next question again we have an M MCQ so here again we Also a code is snippet and at the end of the execution we will print something.

[00:01:29]Over here we are printing something. So we have to tell which option is the correct one here.

[00:01:44]So which one do you think is the correct option?

[00:02:10]40 that is option B. Why?

[00:02:17]>> So C first update value will make C4.

[00:02:22]>> M yeah.

[00:02:23]>> Next will make it six. So 4 + 6 10.

[00:02:28]>> Okay. And then a is already two. So 2 + 2 4.

[00:02:33]>> Okay.

[00:02:33]>> Sorry. Two. Yeah. So >> and then we are just adding the values.

[00:02:40]>> Yeah.

[00:02:41]>> Any doubt in this one?

[00:02:50]>> Okay. I hope not.

[00:02:54]Then we have uh question three. Again, this is an this is uh MCQ. So, which one do you think is the correct option in this one?

[00:03:52]Anyone option C.

[00:04:19]Okay. Why do you think option C?

[00:04:26]>> So D will be 1 2 3 4 and then 5 6 as a tuple.

[00:04:32]>> Okay.

[00:04:33]>> Then E is D of 2 colon. So it will start from 3 4 and 5 6.

[00:04:40]>> Okay. All these values.

[00:04:42]>> Yeah. And then F is D till 2. So it will be 1 2.

[00:04:48]>> Okay.

[00:04:49]>> And then E of two. So E of two is the triple 5 6.

[00:04:54]>> Yeah. E of two is this one. And then we are just uh adding those values.

[00:05:00]>> I think >> that's why we are getting options. Okay.

[00:05:03]Any doubt in this one.

[00:05:16]Okay.

[00:05:18]And uh can you guys uh uh check whether we are you are able to access the form or not? I have shared three forms. So are you guys able to access it?

[00:05:30]All three of them.

[00:06:04]only two is showing I have okay yeah I pinned the third one as well error in opening form two what error are you seeing not accessible or Why you go?

[00:06:31]Okay.

[00:07:32]I've shared uh the link again. Try that for form two.

[00:07:42]What about form one and form three? Are they working or no?

[00:08:21]Okay. So, uh these three forms are mandatory for ES students and I would uh encourage the DS students to also try that all the forms. Okay. So, try to solve them and submit before the session here. Okay. Uh next question. So this is again uh MCQ and here we are given a matrix and uh select the coded snippet that will generate the output. Okay. So there are some coded snippets given and uh we have to mark the snippet that will generate uh the matrix that we are seeing above. Okay. So this matrix.

[00:09:07]So which one do you think will do the task?

[00:09:48]Anyone?

[00:10:07]Which option is the correct one?

[00:10:55]Okay. Uh let's try to see all the options collab.

[00:11:22]Over here uh we have uh two loops this one and this one and uh the matrix is getting created using this.

[00:11:37]So when we do I + J + 1 into 3. So let's try to see what we will get as the first element. Okay.

[00:11:49]So we will have a matrix and there will be three elements.

[00:12:17]So first we are trying to see what we will get at this index. Okay.

[00:12:28]So uh for that what will be the value of I and J? Both will be zero. Right.

[00:12:36]And uh if we try to evaluate this expression when I and J are zero what we will get?

[00:12:47]>> Three >> three. So this option is incorrect right because the first element is one not three and we are not getting that. So this option is incorrect and uh just to show that I'll just show this output. So we are getting three four five and this kind of thing. Okay, you can evaluate uh the letter elements of the matrix but uh that would take a bit of your time. So if you check the first element and it's not matching, you can just proceed to the second option. Now in the second option we have I + 1 and plus J into 3.

[00:13:27]So again we will do the same thing. We will try to first calculate uh the uh 0 comma 0 element. So in that case I and J will have value zero and if we try to evaluate it what we will get one >> one. So that is correct. So let's try to move to Z comma 1 that is this position.

[00:13:58]So for that what we will get four we will get four yeah we'll get four right because I is zero and J is 1. So uh 1 into 3 is three and then we are adding one. So we are getting four that is fine. Then let's try to evaluate uh this position.

[00:14:29]So again that position is also coming as seven because J is 2. So 2 into 3 is six and we are then adding one. So that is seven. So the first row is matching.

[00:14:42]Let's try to evaluate this element.

[00:14:45]So for that uh we will do I is equal to 1 and J is zero. So if we again try to evaluate it we are getting two right because this this part will become zero because J is zero and then this part will become 1 + 1 that is two. So two we are getting. Now what about the central element of the matrix?

[00:15:15]That is also correct right because J into 3 that is 1 into 3 is uh 3 and then we have 1 + 1 that is 2. So 2 + 3 is 5.

[00:15:27]Now we can evaluate this one as well and then other three as well. Okay. So this option is looking correct to me.

[00:15:42]Is this correct or incorrect?

[00:15:49]>> So order of I and J >> is different. Yeah.

[00:15:55]So order of I and J is different. So over here what I is representing?

[00:16:02]Is it representing a row or a column?

[00:16:17]I think column >> I is representing column here and J is representing row here. Okay. So this pattern is correct but the position of I and J are incorrect. Okay. So now we can again try to evaluate this part. The pattern is looking similar to the previous one. But if you see this option and this option, they are the same, right?

[00:16:49]We have just uh uh changed uh the variable I to J. So if you see uh wherever we were using I in this one we are using J in this one and uh J was J is replaced with I. Right? So this is again both the options are same and both are incorrect. Now if we see this option this option is doing the correct thing because the pattern is correct that we just evaluated. Then we have J as the column. So J is in our column and then we have I which is our row. So option D it is the correct option. Any doubt in this one?

[00:17:33]>> So in the second option we were like thinking wrong that 14 we are getting 147 correctly. It was not right. We are getting 147 as column.

[00:17:43]>> Yeah correct.

[00:17:49]Okay.

[00:17:52]>> Like so this is like inside is column and outside is row right sir.

[00:17:57]>> Yeah. Inside is internal one is column and uh your outside one is row.

[00:18:04]>> Okay sir.

[00:18:06]>> See uh when we try to expand this part how we expand it? So let me try to expand this part. So how we will do that? So we will say for J in range three. Okay. So this will be our J. Then we will say for I in range three. Okay. And then we will do whatever we want to do. Okay. Print something or do whatever operation we want to do. Now if you see this J this will represent what? Row.

[00:18:42]Right? In a matrix this will represent a row. and then the internal one will represent column.

[00:18:52]This format you have to uh keep in mind and again this format as well you have to keep in mind that uh the outside one represents the row and internal one represents the one. Okay.

[00:19:08]Now we'll move to the next question.

[00:19:14]Again this one is again an MCQ and we have some code snippet and we have to find the output. Okay, what will be printed?

[00:19:31]So we are given a data and uh we are given some updates and then we have uh a function which we are calling and we are passing the records that is this data and the updates we want to make in the record. So we need to check the logic inside uh the function. What will happen uh to the data that we are passing that is record how is it changing based on the updates and based on that we will pick the correct option.

[00:20:05]So let's try to evaluate this. Okay. So what we will get? So first in this line we are just picking the key and value from the updates dictionary that is this dictionary.

[00:20:26]So the key will be a b c and d in different iterations we will get a b c and d and uh in the corresponding iteration like uh when we are getting the key as a we'll get this as the value when we are getting b we will get this as the value. Okay. Now we are saying if records if key in records then we are just checking whether uh the key that we picked from updates is uh present in data or the records dictionary or not.

[00:21:00]So for a it is present. So this part is evaluating as true. Then we are checking one another condition which is uh is instance of dict or not. So we are for this particular key we are checking its value. This part will give the value.

[00:21:23]This part will give the value of the key and uh once we get that we are checking the data type of this. So the data type is dict in this case. So this is fine.

[00:21:34]Now we are doing this for sub key sub value in value dot items. Now we are moving internally.

[00:21:42]So sub key will become x and sub value will become 10. Right? In the first iteration then we are checking this part if sub key in records keys. So we are checking this x is present in records key or not. So records of key.

[00:22:06]So this part again we are checking whether it's sub sub key that is x is present in this particular dictionary or not. Okay. If it is present then we will do some other operation. If it's not we will do some other operations. If it's present we are adding the sub value. Okay. We are just adding that value. And if it is not present we are assigning that value. So in this we have uh 10 present and from here we are passing five again. So the value of x will get updated right what will it become?

[00:22:51]We already had 10 and now we are in the updates we are passing 10. So will it update >> 15?

[00:23:04]>> Yeah, it will update. It will be updated and we will get 50. Now why? What about Y?

[00:23:16]Y won't be updated, right?

[00:23:18]>> No, it will remain >> because uh in this we are not passing any value for Y. So Y will remain the same.

[00:23:25]And what about Jed?

[00:23:30]it will be added because it was not.

[00:23:33]>> Yeah. So this condition will be uh evaluated and we will add jet. Okay.

[00:23:43]So for a we'll get x = 15, y = 20 and z is equal to 5. Then we will move to b.

[00:23:54]Okay. So we will do the same thing. So for B X will become will be five Y we will add Y will become 10 and zed we already have so zed will remain the same. Then we will do the same thing for C. Okay.

[00:24:14]What will happen to C?

[00:24:28]So 100 will be replaced by x is = 10 with that dictionary.

[00:24:37]>> Why do you think so?

[00:24:41]So because if uh it is checking the updates one if the key like sub val it if it is a dictionary then it is doing this and the update in update C is a diction has a dictionary >> right?

[00:25:00]>> So it will update uh the data part to the new part it will replace it with the new one. Okay, >> because it like if it was already present it would have added but it is not present so it will be replaced.

[00:25:18]>> So in this line we are basically checking whether key is present in records or not. So it is present. First thing is C we are checking C is present in data or not. It is present. Okay.

[00:25:31]Then we are evaluating this part. Okay.

[00:25:35]Whether records key is checked or not.

[00:25:37]So records key is what?

[00:25:40]Records is this right? We are passing data as records and uh records of key key has current value three. So sorry C not three. So we are checking data of C and it is 100 and its data type is not dictionary. So this particular thing is not evaluating to true. So we won't run this part and we'll directly move to else part. And in the else block we are saying records of key is equal to value.

[00:26:13]Okay. So records of key is again what currently it is this. But now we are assigning this value. So when we assign this value is coming from where value is coming from your updates dictionary. So that is why 100 will be replaced by this particular. Okay.

[00:26:37]Now what about D.

[00:26:49]So D will also be added because it is not here. So it will be added in records.

[00:26:57]>> Yeah. So D we will again add. So how we are adding D? Because we are just uh evaluating this condition again. And in this condition we have uh two sub conditions this one and this one. If you check this particular condition key in records that is false right? Because key is currently D and D is not present in records. So that is false. So that's why we again move to the else block and we will run it and we will add D into records.

[00:27:34]So option A this one seems correct.

[00:27:40]Any doubt in this one check the other options. Yeah.

[00:27:46]Is instance is instance is basically checking the type of this thing. Okay, if you maybe say is instance of this. Okay. So it will first uh uh check this and then this. The second uh parameter is your data type and first is uh your data and it will return a true or false. Okay. So 7 is indeed uh integer type. So it is returning true.

[00:28:27]Now if we use 4.5 maybe it is returning false. Okay. So it's just checking the data type of uh your data.

[00:28:38]>> Yes sir. Got it. Thank you sir.

[00:28:40]>> Yeah.

[00:28:45]So option A seems correct here.

[00:28:50]Any doubt in this one?

[00:29:06]Okay, let's move to the next question.

[00:29:14]So again we are we have two functions here.

[00:29:20]Okay.

[00:29:21]So these are the two functions that we have and uh we currently have a list nums and we are doing some operations based on the two functions that we have and then we are printing the value. So let's try to see what uh we are doing using the functions. So the main function that we are calling at the top level is safe get square. Okay.

[00:29:52]Now in safe get square we have try and two accept blocks return get squared items comma I. Okay. So we will try to execute this. If it gets executed and uh we don't find any error then we will return the result from this function. If we find any error like index error or some other type of exception if we find we are catching it and uh uh in case of index error we are returning zero. In case of any other error we are returning minus 5. Now we need to check what this function is doing and based on this we will just evaluate our uh code as so first of all items is what items is a list right and uh we are squaring the uh I is any index like we can pass any index uh from this nums list and uh then we are doing nums of i and uh we are squaring the value.

[00:31:08]So for this what do you think what uh will be printed -1 0 or some other value.

[00:31:37]So we'll get four.

[00:31:41]>> We will get four. Why?

[00:31:44]>> The index is one here. So -2 will be taken and -2² will.

[00:31:54]>> Okay. So we uh we are calling this function and uh I items of I is giving minus2 and we are just squaring that value and printing it. So the first line will print four. What about the second line?

[00:32:14]>> So nine.

[00:32:17]>> So it will print nine. Why? Because uh minus one will give us three and we are just uh squaring it. So we are getting okay. What about the third uh line sir?

[00:32:31]>> Zero.

[00:32:33]>> Zero. Why?

[00:32:35]>> Because the list is empty and last index is uh empty sir.

[00:32:42]>> Okay.

[00:32:45]So do you think this line will be executed?

[00:32:57]>> Yes sir.

[00:32:59]>> Okay.

[00:33:00]So in case of uh empty list we are trying to access uh the minus one element and that is not present. So we will raise uh index error but in the function we are catching that error and uh we are returning zero. So that's why we will get zero.

[00:33:22]What about the last one?

[00:33:32]So minus one because it will be an error but it is not an index error. So we will return minus one.

[00:33:40]>> Yeah. So we will return minus one.

[00:33:45]So option this one seems correct. Option D.

[00:33:51]>> Yes sir.

[00:33:52]>> Okay.

[00:33:55]Let's move to the next question.

[00:33:58]This is an MSQ. So, we may have multiple correct options. Let's try to evaluate all the options.

[00:34:09]Okay. What do you think what uh okay it's talking about uh the prints only. So, let's see what we are printing. What will this print?

[00:34:34]So 3 4 5 >> 3 4 5.

[00:34:41]So T3 is basically the combination of uh these two tpples and then we are saying 2 to 5. So 2 is three then four.

[00:34:56]Do you think five will also be there?

[00:35:02]>> Yes sir. Because it will go from 2 3 4.

[00:35:04]It will not go till five but till four.

[00:35:07]So >> index four I mean.

[00:35:10]>> Yeah correct. So it will pick three four and five. What about uh this one? length of T4 s two.

[00:35:26]>> Why?

[00:35:28]>> Because T4 is the tuple of tpples T1 and T2.

[00:35:33]>> Yeah. So, uh nested, right?

[00:35:38]>> Yes sir.

[00:35:39]>> Okay. So, this option is correct. Option B is correct. Option C is also correct.

[00:35:46]Let's see other options. So what about this one? What will this print?

[00:35:56]>> So true.

[00:35:58]>> True because we are just checking five is there in T2 or not and it is present.

[00:36:03]So we'll just print true. So option four is also correct.

[00:36:18]Okay. So, option four is also correct.

[00:36:21]What about uh this one?

[00:36:36]So, print t1 will return one.

[00:36:41]Y1 because here we are trying to assign some value. So t1 of 0 is equal to 10.

[00:37:05]We are trying to change this value and tpples are immutable right. So it will throw an error and we'll move to the accept part and in except we are saying that t1 is equal to t3 of zero. Now t3 is what t3 is combination of this and we are just picking the zeroth element.

[00:37:29]So that is one. So that's why t1 will be zero sorry one. Any doubt?

[00:37:40]>> So, so like hold T1 can be replaced but inside T1 we cannot replace right.

[00:37:46]>> Yeah.

[00:37:48]>> Okay. So >> in tuple and uh in a string they are immutable. So you can't do character or element replacement in them. Okay.

[00:38:03]>> Okay. So >> then t1 will become one. It will not not remain a tle anymore. Right after >> yeah yeah yeah >> this.

[00:38:13]>> Okay.

[00:38:15]>> So option B, C and D are correct and all the other options are incorrect.

[00:38:23]Any doubt in this one?

[00:38:27]>> No.

[00:38:29]>> Okay. Again, we have uh an MSQ and Okay, this looks a bit weird.

[00:38:54]Okay.

[00:38:57]So these are your options and uh this is just notes to understand few things okay related to the question.

[00:39:10]So we have a file and the name is text txt and over here we are trying to open it.

[00:39:22]We are basically opening it and we are doing some operation some write operation and then finally we are again opening that file and uh reading it and printing some stuff.

[00:39:35]So based on this if you want you can read this as well and based on that you have to tell which options are correct.

[00:40:21]Just to give the idea of what the f the content of the file are what's inside the file I'll just print this so that you can see it in the exam you won't get this option but uh just for convenience I'm printing this value. Okay.

[00:40:46]So this is the content of the file that you will see inside the file. Now we are uh reading the file and printing some stuff.

[00:41:09]Option one is it correct or incorrect?

[00:41:13]The first line of the output is line three.

[00:41:19]>> Yes sir.

[00:41:22]>> It is correct.

[00:41:34]Okay. Why do you think uh first line will be line three?

[00:41:41]>> So because we are reading two lines and then printing the third line like print f. Five. So it will remain at line three because there are five characters there more than five.

[00:41:54]>> Okay.

[00:41:57]>> Correct. What about uh second option?

[00:42:00]The second line of the output is line five.

[00:43:04]is option B correct or incorrect.

[00:43:28]So I think it is correct.

[00:43:31]>> Okay.

[00:43:33]So if that is correct that means uh option C is incorrect.

[00:43:41]>> Yes sir.

[00:43:44]>> Let's try to maybe run this and see what is happening.

[00:43:53]I'll first print the first part.

[00:43:57]Okay. Line three as we expected.

[00:44:02]Let's try to print this part as well.

[00:44:07]We are getting line four.

[00:44:31]Is it correct or incorrect?

[00:44:38]Option B.

[00:44:41]>> So this shows it is incorrect.

[00:44:43]>> It is correct. It is incorrect. How? See what is happening over here.

[00:44:49]So first we did app read line. It read this. Okay. Again we did uh f dot read lines. It again read this. Then we are printing f read five. Okay. So it is reading this part till three and it is printing. Okay.

[00:45:14]Now we are again doing f dot read line.

[00:45:19]What will it do?

[00:45:24]will read this line.

[00:45:27]>> Yeah, it will remain at that line.

[00:45:29]>> Yeah. So, it will read this line again.

[00:45:33]And then we are doing after read 10. So, now we are here before this line. Okay.

[00:45:42]Before this line, we are at the beginning of of this line over here, line four. And then we are printing 10 characters. So five characters are there. Then we have back slashn that is one more character. So six characters and four characters again. So that is why we are getting this particular thing. Okay.

[00:46:08]So s that just before read the f dot read line that will only read the slashn and move to the next line I mean beginning of line four.

[00:46:21]>> Uh repeat that again.

[00:46:23]>> So after f do read five.

[00:46:26]>> Yeah >> it was at three line three.

[00:46:31]>> H >> so now that f dot read line will uh read the new line character after three.

[00:46:37]>> Yeah. So it will move to beginning of line four.

[00:46:40]>> Yeah.

[00:46:41]>> Okay.

[00:46:42]>> And now we are uh doing this. So we are printing line four and then line. This particular thing we are printing.

[00:46:52]And then we have f.sek0.

[00:46:56]So did you check what seek does? So the method fert moves the position of the file pointer to the given number of characters after the start of the file. So what will f do seek zero do?

[00:47:18]>> Move to the beginning 03.

[00:47:22]>> So it will move over here. Okay.

[00:47:27]to the beginning of the file itself.

[00:47:30]So the method basically uh if you read this part the method moves the position of the file pointer to the given number of characters after the start of the line. So the parameter that we are passing over here is zero. So it will from the beginning of the file it will move zero character. So zero character moving zero character means it will stay at the starting of the file at the beginning of the file. Now from there we are again printing five characters. So if we try to print that this is clear right again we are doing two times f read line and then we are again printing this part. What will this print?

[00:48:22]The last line. What will that print?

[00:48:34]>> Line four.

[00:48:37]>> Line four.

[00:48:41]Sure about that?

[00:48:47]>> Yes, sir. because we have two red lines.

[00:48:51]>> Okay.

[00:48:55]>> Okay. The new line character.

[00:48:57]>> Yeah. So, uh once we execute this, we are printing line one and the pointer is at the end of uh this line. Then when we do f read line, the new line character gets read and we move to the next line.

[00:49:13]Then we print this and then we are printing this. Okay.

[00:49:21]I hope this is clear. So, so every read line will read >> the current >> from the current >> from the pointer it will like it will uh try to find uh the back slashn new line character and once it reaches that it finds it uh it will just move after the new line character and stop there.

[00:49:48]>> Okay. So like new line character means if whenever it finds new line then only it goes to the next.

[00:49:56]>> Yeah.

[00:50:02]>> Okay. Uh I hope this is clear.

[00:50:06]We can check question number nine. This is uh based on class and we have to guess the output.

[00:50:26]Okay.

[00:50:28]So what do you think what will be the output? So we have two print statements.

[00:50:36]So what do you think what will be printed?

[00:51:15]what will be printed for this particular question?

[00:51:25]So for rectangle it will print I'm a shape and the area >> 20.

[00:51:34]>> Okay. What about uh circle >> this line >> circle plane print area not defined because >> area not defined because uh in circle class we haven't defined.

[00:51:51]Okay.

[00:51:54]Uh any doubt in this one?

[00:51:57]Basically this option is true and others are false.

[00:52:07]Any doubt in this one? If not, I'll move to the next question.

[00:52:19]Okay.

[00:52:23]Now question 10.

[00:52:28]So we are printing the sum of a list and the list is getting created over here.

[00:52:38]So over here we are creating the list and then we are printing the sum of the list.

[00:52:45]So what will be the elements of the list?

[00:52:56]First tell me the elements of the list and then we will try to find the sum of list.

[00:53:39]Okay. What will be the first element of the list?

[00:53:47]>> So 1 10.

[00:53:49]>> Okay.

[00:53:51]Then 10 then >> 2 and 20 >> 220 >> 330 >> M >> 440 >> That's it.

[00:54:04]>> Yes sir.

[00:54:05]>> Okay.

[00:54:07]Now we are saying uh this is equal to 10 and then we are uh summing this thing. What will happen?

[00:54:31]>> So 0 0 will also come in the beginning.

[00:54:37]Zero Z will also come.

[00:54:40]What do you mean by that?

[00:54:42]>> Oh, okay.

[00:55:04]What will be the sec? What will the second last line do?

[00:55:13]This line. What will this do?

[00:55:33]So 0 0 will also come because I in range five. So I will start from zero. So list will be 0 0 1 10 220 330.

[00:55:43]>> H correct.

[00:55:49]>> And so this line will replace three elements with 100.

[00:55:55]>> Okay. Starting from 1 to 1 2 3 elements will be like starting from index one index 1 2 3 will be replaced by 100.

[00:56:07]>> So the first ele the element at index one was uh zero then at index two we had one.

[00:56:20]>> Yeah 0 1 and 10. Yeah 0 1 and 10 will be replaced by 100. Okay. So what we will get finally what will be the list?

[00:56:36]I'm dropping the elements in the chat.

[00:56:41]So we have this and then we are replacing the elements 0 1 and 10 and putting 100 uh there. So what will be the sum now?

[00:57:01]155.

[00:57:04]155.

[00:57:06]Nope. We are getting 199.

[00:57:14]You want to check it again?

[00:57:30]Yes sir I missed that 449 199. Yeah.

[00:57:35]>> Okay. So we will get 199 and uh the elements of the list are the after this operation we will have zero then comma 100 2 3 4 and 40. Okay. So these are the elements of the list and then we are summing them. So we are getting 198.

[00:57:58]I hope this is clear.

[00:58:04]Okay.

[00:58:06]So now we again have an NAT.

[00:58:12]Okay. So what will be the output of uh the given code?

[00:58:18]We are doing some operation again on a list. It is an array and seems like it's nested array. So let's see what we will get.

[00:58:35]So we are creating a row and the elements are calculated using this appending the row and this will form the array and then we are uh processing the array.

[00:58:52]So first of all tell me what will be the elements of the array what we will get after executing this part.

[01:00:15]Okay. Uh in the first row, what will be the elements in the first row?

[01:00:26]So 1 3 >> 1 and three both.

[01:00:33]>> Yes sir. Because I + 1 is the range.

[01:00:38]>> Yeah.

[01:00:40]>> When I is zero, J will go to zero and one.

[01:00:46]>> Not one, right?

[01:00:49]>> Okay. Okay. Okay. Yeah. Only zero.

[01:00:52]>> Only zero. Yeah.

[01:00:54]>> Only one. Yeah.

[01:01:01]So this will be only one. What about the second row?

[01:01:11]Now I is one and uh J can have value zero and one.

[01:01:33]Two and four.

[01:01:38]>> Two and four. Okay.

[01:01:41]And four. Here it is. What about the next one?

[01:02:03]36 time.

[01:02:06]>> Okay, we are getting a pattern.

[01:02:10]>> Yes sir.

[01:02:12]>> So now I'll just write four date.

[01:02:18]Sorry. 12 and then 16, right?

[01:02:23]>> Yes, sir.

[01:02:28]5 10 15 and 20.

[01:02:34]>> 15 20 and 25, right?

[01:02:37]>> 25. Yes, sir.

[01:02:39]>> Okay, let's try to print it.

[01:02:49]Okay, I hope this is clear.

[01:02:55]If this is clear, now we know what is array then we have a function closest process array and we are printing whatever we are getting from that function. So what uh will be the value of total What will be the value of total at the end of the execution?

[01:04:09]Okay. Uh what will be the value of these things? So in the first iteration what will be I and row.

[01:04:24]Our matrix is this and I'm asking about I and row. So in the first iteration what will be the value of I in >> zero and one like first row.

[01:04:40]>> Yeah. So I will be zero and uh first row is uh this particular thing. Okay. This list.

[01:04:50]>> Yes sir.

[01:04:52]>> Okay. And now we are uh trying to add uh the value that we have at zeroth index in the list. So that is one. So total will be after the execution total will become one.

[01:05:05]>> In the next iteration we will have i is equal to 1 and row is what row is >> 2 4. So end yeah end one will be added.

[01:05:15]>> We are adding this again. We will do the same thing. In this case we will add 9 then we will add 16 and then we will add 25. Okay. So what will be the sum?

[01:05:30]Let's try to do this. What we will get?

[01:05:34]1 we have 4. We have 9. We have 16. We have and 25. We have 55. Okay. So 55 will be your answer. Any doubt in this one?

[01:05:55]Any doubt how are we getting 55 and why did we pick the last elements?

[01:06:07]Okay, I hope this is clear. So our answer is 55.

[01:06:14]Now again this is again NAT and uh we have a function defined over here. We are doing some operation on a dictionary and uh then we are calling the function with the dictionary and this is index I think I is with maybe index. So we are calling it and printing the value.

[01:06:42]So this is here we are creating an empty dictionary and uh at uh like uh when the key is zero for uh key zero we are assigning the value 1 2 for key one we are assigning value 3 4 5 in list format and uh for key two we are assigning this value and then we are calling the method at index zero.

[01:07:16]So let's see what is happening in the method.

[01:07:26]So here what we will do we will check if I not in child keys. So child do key will give us 0 1 and two and we are checking whether I is there or not. So I is present in the dictionary. So we will not evaluate this part. We will move to this particular part and then we will evaluate. So n is equal to 1. We are initializing. Then we are doing for J in child I answer is equal to then we are calling basically this is a recursive call. So for J in child uh dicty so we will get uh two values for uh J 1 and two and uh then we over here we are adding the values okay so let's try to evaluate this now we are calling this particular ular thing procedure again and uh now we are passing the index j. So in the first iteration the first iteration of this part j will have value one. Okay. And uh when we pass J in this we will go to this particular thing where key is one and we will again check all the child of what J right that is one. We will check all the uh children and uh then we will pick the first child because uh again when we pass uh this thing when we call this we will again hit this part and this in this part we will have uh this particular thing and instead of I we will have J in that case. So okay and uh when we do child dict of J that is one we'll get this thing. So in that case we will have uh in the first iteration we will have three and again we will check whether three is there in child dect or not. It is not. So we will return one.

[01:09:58]Okay.

[01:10:00]So we are doing that. Is this clear or do you want me to explain it a bit more?

[01:10:13]>> So, so answer will be one.

[01:10:16]>> Not one.

[01:10:20]Answer won't be one.

[01:10:25]We haven't come to that yet. I just explained that uh uh we will basically check all the children and uh based on some operations that we are doing inside this particular method we will add some value and finally we will return answer. This is recursive call. So yeah is the recursion part clear? If not, uh, let me Okay, let me pull this up and try to explain it further.

[01:11:38]Okay. Are you guys able to see the whiteboard that I'm presenting?

[01:11:47]No sir.

[01:12:14]What about now?

[01:12:17]>> Yes sir.

[01:12:19]>> Okay. So let me clear this part first.

[01:12:33]Okay. So initially what is the value of I? I is uh zero right from here we have passed zero.

[01:12:42]>> Yes sir.

[01:12:43]>> Okay. So Initially we have passed zero.

[01:13:14]I'm using touchpad so I might write something weird. So try to e and understand. Okay. uh then over here we are checking whether I is present in child dict or not okay so for zero it is present right >> yes sir >> so this condition won't be evaluated we will directly move to this part okay now we are saying answer is equal to 1 and then we are doing this part okay so J will have two values What? Two values >> one and two.

[01:13:58]>> One and two. Okay.

[01:14:05]Now over here we are again calling this function. Okay. And uh we are calling it with the value of J. So in the first iteration J will have value of one.

[01:14:20]>> J will have this value. Okay.

[01:14:23]And uh we again called this method and uh now we passed uh one as the second parameter. So again this particular thing will be executed. Now we will again try to see we will again try to execute this part and uh we will see whether one is present in child or not.

[01:14:48]Right?

[01:14:50]It is again present. So return one won't be executed. We will again move to this part. Is this clear?

[01:14:58]>> Yes sir.

[01:15:00]>> Okay. So now we are again executing. And now we are executing for one.

[01:15:12]Now we'll again try to execute this. And it is again saying child dict of I. So currently since we passed one over here so I is one basically and uh we'll check all the children of I.

[01:15:28]So that is 3 4 and five.

[01:15:33]Any doubt in this part how we are getting 3 4 and five?

[01:15:39]>> No sir.

[01:15:42]Yeah. So we got these three this is fine and >> yeah then we are again calling this part and uh we are picking the first value so that is three we are picking this value again calling the function and uh then we are executing this part.

[01:16:10]So when we try to execute this part so first we will evaluate if I not in child dict keys or not. Okay. So we will evaluate that and that is true right for three that is true because >> child dick has only three keys and they are 0 1 and two three is not present. So we are getting true. So in this case we will return one right >> one. Yes sir. So answer was one initially we initialized it to one and because of three this particular thing again returned one. So answer become became two right?

[01:16:50]1 + 1.

[01:16:54]Now three is done. So let me remove this. Three is done. Now we will move to the next child. The next chain. So four again. Four is again not present. Remove this. So answer became three. Right?

[01:17:12]Five is also not present. Five we also crossed.

[01:17:18]Answer became four. Right?

[01:17:22]Now one is done because uh one had uh one had uh three children and we executed for all of them. So one is completed. Now we will move to two.

[01:17:36]Okay.

[01:17:38]So, two has three values. 6, 7, and 8.

[01:17:43]We'll do two and two has 6, 7, and 8.

[01:17:58]We'll evaluate six first.

[01:18:01]Six is not present. Again, one will be added to answer. So answer is basically 2 3 4 and five and uh then we will do seven. Seven is also not present again one will be added. So we have six eight we will do because of eight we will again add one.

[01:18:26]So we have seven now right?

[01:18:33]Then two is done.

[01:18:41]Any doubt till here or is it clear?

[01:18:47]>> Yeah, it is clear.

[01:18:52]>> Okay.

[01:18:54]So for this one we are getting how many?

[01:18:58]1 2 3 crossed 1 2 3 4 5 6 and these two eight and answer was already initialized to one. So eight we encountered over here and one was already there. So total nine values we encounter. So answer will become at the end of the execution answer will become nine. Right?

[01:19:27]>> Yes sir. Any doubt in this part?

[01:19:37]Okay.

[01:19:41]Let's move to next question.

[01:19:50]Again this is uh again a numeric type question and related to class.

[01:19:58]We are printing one value over here and we have to find uh the output that is this print value itself.

[01:20:10]So what will be printed?

[01:20:30]Anyone?

[01:20:49]What will be printed?

[01:21:18]This one is not very hard.

[01:21:31]Okay.

[01:21:33]Uh see this. So we are initializing an object of class uh B okay and then we are calling this function. So first we need to see uh what this function is doing and uh for that we need to evaluate uh the class uh B. Okay.

[01:21:55]So if you see here we are uh calling this function uh calling uh this and inside that we are calling the init method. So super is basically what super is the super class.

[01:22:08]So we are initializing this class and uh inside that we have the init method we are calling that. So because of that we will have self dot value is equal to five. Okay. So B will have self dot value is equal to five.

[01:22:24]Now we are doing this. So what will be the value of self dot sorry yeah uh what will be the value of self dot value after this we are multiplying by two and when we initialize we had uh five so 10 right the value of self dot value is 10 now and then so after the initialization that will be your state and then you are calling this function object dot add three this part.

[01:23:00]So over here again we are doing super and then we are doing dot add num to two. What will this do? What will this particular uh part do?

[01:23:28]What will happen again? We are doing the same thing what we did over here. Okay, same thing.

[01:23:44]So we have add method defined in the super class. So we are using that and we are calling that add method and we are passing num into two. So what is num?

[01:23:58]Num is three. So 3 into 2 is six. So we are calling this particular method and the the parameter that we are passing is six and inside that we are doing self dot value plus num. Okay. So num is six and self dot value we just calculated because of this it was 10 right five we initialized with and then we multiplied by two so 10 and then we once we evaluate this particular thing so 10 and uh n into 2 is six so we'll get 16 is it clear how We are getting 16.

[01:25:02]Any doubt in this one?

[01:25:18]Okay.

[01:25:20]So I hope this is clear.

[01:25:23]Let's move to next question.

[01:25:28]Question 14 is uh comprehension and it has two parts. So let's try to see what we have in the comprehension part and then we'll see the question. Okay.

[01:25:47]So we have a file name, number of lines, seek position, override position and override text.

[01:25:59]We are calling a function create and write file which is this number of lines from here we are passing and let me try to show what we are getting.

[01:26:48]Okay, this is the file that we are putting. Okay, because of this particular thing and number of lines we passed, we are getting six lines and uh the lines are the line one to this kind of format we have followed.

[01:27:06]Okay. And then we have another method override some text and uh it is accepting a file name that is this only. Then overrite position we are passing 21 and then overrite text we are passing and based on that it is overwriting something and then we are uh writing that thing.

[01:27:31]So let's see what is happening over here. This is the logic that we need to figure out and after that we can answer the question.

[01:27:43]What will this do?

[01:27:49]So we used uh the seek method uh just now few questions >> 21st see character.

[01:28:03]>> Yeah. So 21st character from this beginning. So we need to count the characters. So 4 5 6 and then we have uh the back slash n that is seven. So first line has seven characters. Second also has seven. Third also has seven. So that is 21.

[01:28:25]So whatever we will do it will appear over here. Okay.

[01:28:31]Now we are doing original is equal to after read line.

[01:28:37]What will this do?

[01:28:43]original will become line 4/ line 4/ we are doing uh yeah line for/x again we are doing the same thing app f seek override position what will this do >> line it will go to line seven >> line seven it will go to line seven.

[01:29:17]Okay. And then we are saying f dot write text back slash n text is what text is overrite text that uh is this one. So in line seven you are saying we will add uh this particular text right this particular thing we will add.

[01:29:38]Correct?

[01:29:39]>> Yes sir.

[01:29:41]Okay, let's try to run this. See what's happen.

[01:29:54]We are getting this.

[01:30:06]Why are we getting this?

[01:30:14]So whenever we call f seek it is starts from the beginning. Okay this was written right in this particular thing.

[01:30:30]So whenever you will call do seek method it will always start from the beginning of the file and it will move n character. So n is whatever you are passing as the parameter. So we are again passing over right position. So this uh for this the pointer move to the beginning of line four. Okay.

[01:31:02]For this also it will move to line four only. This beginning of line four and then we are writing this particular thing.

[01:31:16]Okay. Any doubt in this one?

[01:31:23]So sir why line five was modified line five we will come to that but uh is this part clear or uh >> yes sir this is >> okay so if this part is clear let me close this redone this okay we are getting the same Now I'll come to that part. Okay. Let's first try to see what uh is uh 14.1 file.

[01:32:02]How many number of lines will be there in the file example file dot text?

[01:32:11]We are seeing how many lines? Five lines. Right? Six. the sixth line you don't need to count. So five lines are there and uh whenever we use Python to write files it generally adds backslash and at the end so we don't uh count that line.

[01:32:30]So five lines are okay. Okay. So we have five lines.

[01:32:45]Any doubt in this one? I have uh shown the output as well. So it should be clear that we will get five lines.

[01:32:57]Now we have what will be printed if we call random access read this immediately after running the given code. Let's try to see this what we are getting.

[01:33:19]Okay. So in this what we are doing we are first uh reading the file. So in the first line we are reading the file then we are saying f read five. F dot read five we are storing in first character.

[01:33:36]F dot read five is this part line and space.

[01:33:42]Then we are doing f see seek position.

[01:33:45]Seek position is 10.

[01:33:51]Right?

[01:33:53]So we move to 4 5 6 7 8 9 10.

[01:34:02]We'll move forward here.

[01:34:05]Then we are doing line is equal to f dot read line. So it will complete this line and move to this line line number three. Then we are doing rest is equal to f dot lines. So f dotl lines we are doing. So all these things will be stored in rest in a list format and then we are just printing the lines. So first line will be this. Then we will get this as the second line and then this will be our third line.

[01:34:44]Any doubt in this one?

[01:35:06]Okay. Uh now coming back to the question why we are just uh getting this part. Okay. So I think till here everything is clear. The confusion is why like previously we had few more lines.

[01:35:30]until line six was there. Then we ran this part and the file content changed.

[01:35:45]So if you see what does this mean? R plus anyone.

[01:36:02]What does R + mean?

[01:36:05]Read plus write that is true.

[01:36:14]Over here when we are calling F.Right Right.

[01:36:17]>> It is reading the file and writing also.

[01:36:21]>> Yeah. Both things.

[01:36:25]So when we are calling this f.right text, it will replace the content. Right?

[01:36:38]Is this clear? It will replace.

[01:36:42]>> Yes sir.

[01:36:44]>> Okay. Now because of this part where is our personing of line four.

[01:36:59]>> Beginning of line four and then we are writing.

[01:37:04]>> Yes sir.

[01:37:06]>> We are writing what?

[01:37:09]>> Overwritten text.

[01:37:11]Yeah.

[01:37:14]So that we are writing and because of that we are getting this content and uh the later parts are getting removed.

[01:37:23]Is this clear?

[01:37:27]>> No sir sir why those are getting removed because we are replacing that line only.

[01:37:32]No >> this line.

[01:37:37]>> Yes sir. Line four we are replacing. Why line five is getting affected?

[01:37:43]>> So we are doing g right now >> when we let me show it replaces the character count.

[01:37:57]What character count >> from line four to the n in line five?

[01:38:04]You're replacing 16 characters, >> right?

[01:38:17]Okay. Okay. Understood.

[01:38:20]>> Is this clear?

[01:38:23]>> Yes sir.

[01:38:24]>> Okay.

[01:38:27]So if this is clear I hope uh question number which we did this we already did and uh this I already showed you. So what was it printing these three things right?

[01:38:48]>> Yes.

[01:38:50]>> Okay. So option this one option B >> yes >> okay any doubt in the previous question number 14 okay let's move to question 15 then again this is uh a comprehension based question we have a code snippet given over here and based on that we have some questions. So let's see what is happening over here.

[01:39:31]So we have a method defined and inside that method we are calling that method basically and uh we are passing a list to that method and inside that method what we are doing we are saying categories is equal to dictionary and uh it has three keys and uh currently all the three keys are mapped to empty sets and we have one function over here and we are doing the iteration over here for num in nums. If num is divided by two, num is uh uh num is basically uh an even number.

[01:40:18]If it is an even number, we are adding it to category 1. Okay?

[01:40:26]Else we are adding it to category two.

[01:40:30]If check num then we are adding it to category three and check num is doing basically this thing whether uh num is divisible by five or not. So if it is divisible by two we are adding to uh one category one. If it's not divisible that is odd number we are adding to uh category 2 and category 3 only when any number is divisible by five. Is this clear?

[01:41:04]>> Yes.

[01:41:06]>> Okay. So what will be the value of the following expression after running the given code snippet sorted result this and this what will be the result for this one we have some options let's see that as well what What is the type of uh this uh result category one? What is the type of this divisible by type? I'm asking what is the type of uh result category one >> a set >> it's a set right >> it's set >> both are set >> yes >> and we are doing and operation so in set what does and operation do >> intersection >> intersection so what we are basically saying that we want the intersection of this and this set correct.

[01:42:32]So >> yes, >> what will be the value?

[01:42:37]>> 10.

[01:42:40]>> Only 10.

[01:42:45]>> Yes, only 10.

[01:42:46]>> Yes.

[01:42:47]>> Yeah. So because uh category 1 is just storing even numbers and uh category 3 is storing dividal five. So we will just get 10 as the common.

[01:42:58]>> Okay. What about uh this one?

[01:43:02]What is this pipe operator >> or pipe is or okay.

[01:43:14]So what will happen? What we will get?

[01:43:17]Union pipe is union. Okay.

[01:43:25]So what will be the value of the expression it's asking for length >> n.

[01:43:48]How >> what are you have 10?

[01:43:55]>> Okay. So we will have 10 values.

[01:44:00]So what are the values in category 1?

[01:44:07]>> 2 4 6 8 10.

[01:44:10]>> Okay. And uh category 2 >> 3 57 9 >> 3 5 7 9 All the even numbers are in category one and odd are in two. And what about uh category three? Five and 10, right?

[01:44:29]>> Yeah.

[01:44:31]>> So what's the total if we add all of them?

[01:44:37]>> Nine.

[01:44:41]That's union.

[01:44:43]So uh yeah we have to do the union. So that will be nine. Okay.

[01:45:02]Any doubt in this one?

[01:45:06]15.2 two.

[01:45:16]Okay.

[01:45:20]So again 15.3 is an MSQ and if result is equal to this which of the following expressions will be evaluated as true.

[01:45:32]So first option is it correct or false?

[01:45:39]Correct.

[01:45:40]>> It's correct because category one is storing even from this list. Category 2 is storing odds and category 3 is storing the uh the numbers that are zero five.

[01:45:57]What about this one?

[01:46:06]This is false.

[01:46:11]>> Sure.

[01:46:11]>> It is only one.

[01:46:14]No. No. Wait.

[01:46:16]>> 10 and 20.

[01:46:17]>> It is true.

[01:46:19]>> It is correct. Right. This is correct.

[01:46:21]>> This one is This one is false or true?

[01:46:29]>> False.

[01:46:31]>> False. Okay. And what about this one?

[01:46:47]This is also false. Why? Because these all these numbers are unique and we are just creating three categories and all numbers are getting distributed in these three categories itself. So if we do the union operation we will again get this whole thing right.

[01:47:06]So this is again false. So sorry we have and operation. Yeah and operation. Okay we have and operation over here. So no that is not true.

[01:47:27]So if we do result of category one and uh category two what we will get for this part >> empty set >> empty set empty set correct and uh because of this we will get just uh category three and category 3 is this one. Okay so last one is also correct.

[01:47:49]>> Yeah.

[01:47:50]>> So option A, B and D they are correct.

[01:47:56]Okay, so that's pretty much it in this set. Do you have any other question?

[01:48:05]If not, I'll just close the session.

[01:48:15]Okay.

[01:48:18]And uh have you guys uh completed the form, submitted the form after solving the questions in them?

[01:48:30]If not, uh please do it in next 5 minutes. I'll close the forms after that. Okay. Thank you.

[01:48:41]>> Thank you, Sun. Yeah.

[02:01:55]This person sounds differentiate different There you go.