Warm Dingo: Hello
Mighty Jaguar: Yeah. Hi. Can you hear me?
Warm Dingo: I can. Can you hear me?
Mighty Jaguar: Yeah.
Warm Dingo: Awesome.
Mighty Jaguar: Yeah, sorry for being a bit a few minutes late.
Warm Dingo: That's fine.
Mighty Jaguar: Okay, yeah. And yeah, so the format will be just tell me briefly like, not your name or anything. But like briefly like, how much years of experience you have, what you're looking to get out of a out of this interview practice. And then we can then go through the coding. Try to do one or two, depending on your speed. And we'll, we'll keep like 30 35 to 40 minutes for the code. And then I'll give you feedback.
Warm Dingo: Okay, awesome. Yeah. So, so I have around nine years of experience in software industry. And mostly I've been on the platforms slash system side on, on the software networking side of things, not on the not on the cloud side website or something mostly back end system development. What I'm trying to get out of this interview is I've been trying to interview outside my domain for a while. I'm trying to get hold of leetcode type of problems. Right. So I'm just need to get used to more of those sort of things, right? Just generic data structures, algo type of problems. Right. So, and I just wrote, I've been practicing for few weeks now. So I just want to get some real feel of how things are going. Okay. So let's say we could we could go ahead now, I think. I mean, yeah.
Mighty Jaguar: So about being I'll just give you a brief like, I have been in the industry for a few years now. Like almost like 5 years. I've worked in FAANG companies, if you're targeting let me know and then you can ask the question accordingly. And, and, yeah, I've been interviewing for now, like, two, three years now.
Warm Dingo: Awesome. Yeah, I think you could keep the FAANG format. Right. I did interview with Facebook networking. One year ago, I did an on site. I remember I did solve all the questions. But I believe that I did do mistakes, in terms of not really grasping what exactly the interviewer was asking for. Because the questions are also not well formed, they were trying to mostly it was not like, it was not a copy paste of actual leetcode questions on the bank. It was more like a personalized question from the interviewer. So he probably they were trying to get the question drawn out of me rather than them giving the question something. So yeah, I think you could keep the FAANG format type of questions, right. That's what I think that could help.
Mighty Jaguar: Okay. So let's do this. Do you want to choose the language?
Warm Dingo: I usually chose the language based upon the question I only know two languages. One is C. C is where I make my bread and butter day in and out but for leetcode type of interview type of things, I'm using Python, right. So I will use Python for that unless you are asking some kind of concurrency type of questions. Then there is mostly going to be Python.
Mighty Jaguar: I mean, if you want you can use C. Okay. So let's say you have an XML. So, my first question is like, how would you design this? Like if you if you had to like what class will you be how will you keep the values and those kind of things? XML has attributes and other things, but for simplification, let's just do this only.
Warm Dingo: So, is the problem trying to extract the value and store it specifically or something like that?
Mighty Jaguar: If you have to solve this format in a meeting you want right.
Warm Dingo: So, so, it is... there are a few ways of looking at it right. In case if we are trying to take a key to value type of an approach to get something and if the key is something going to be something like a dot b dot c, right? And if they want like a key out of it, right, which is Y right, then I believe we could use like a trie type of a data structure, right? Because the structure of the data is recursive, I believe right? That's probably... a trie would be efficient in accessing because the we'll have to if we know the format of the key in a key value store to be something of this format, and if there is a specific format to the key then we could always figure out sub node within the trie for the indirection until we find the end node and within that we can get the value.
Mighty Jaguar: I want the structure like I want to have... trie is good but might let's say I had the make you know so, I had it like okay give me a and then if I go below it should give me b i go more deeply children or something right and you can use trie. One thing that I would add is like a child can also have value a parent can only have a child, it cannot have values. So b cannot have value or a cannot have value because there's a child and the child.
Warm Dingo: Okay, okay. So, in case if a has a child, it is either going to be another hierarchy or it is going to be a value? Okay, so then we should be able to differentiate whether the child is a another indirection or whether it is a whether it is a value. So that we could pass it further or not. Right. Something like that. So, yeah, so I believe we could still do that with a trie.
Mighty Jaguar: Sorry and one more thing while you're solving a lot more and more things to make it easier and make you go in that direction.
Warm Dingo: Yeah. Yeah. So is that approach require where what we want to get out of it is... Do you want to be able to do like a iteration of this and store it in some data structure such that we could do a lookup based upon a key or I mean, you're trying to keep that one open, right?
Mighty Jaguar: I don't care how they are going to use it. I'm going to pretend like I'm given this XML. And I'm going to extract this into an object layer. Now, how do you how does that object look? How does that class, that's what I want.
Warm Dingo: Okay, and so, so we need to be able to differentiate, let's say, we have an just trying to design XML.
Mighty Jaguar: You wouldn't be able to code it, I just want different designs that you can think of like. How it's actually planned. Right.
Warm Dingo: So yeah, I think I mean, there is a way where we could look at it in the form of a if, for example, a, here as B as an object underneath, right? And, and B is terminated and followed by that we have d. So a has more than one child, right? And we could, in reality, or we could just list them together, it doesn't really need to be like, we could key it, right? We could have like a hash table underneath. Or we could just have like a list of children under. So that kind of gives a linear view to the data structure as well.
Mighty Jaguar: For example, if you have a hash table, how would you keep in mind, if you had a list? How will you keep? And what are the pros and cons for them?
Warm Dingo: Right? So if you keep hashtable, let me start with a list. Right? So if we keep it as a list, the problem is.
Mighty Jaguar: If you can write it, you know, sad that it might help you? Sure. You don't have to, you don't have to try to like, you know, keep the comments and just.
Warm Dingo: Yeah, so if I'm just trying to, like, have a scratch space here, right? So if we have an object, right, we could have something like, is each object can be something like is value, right? There's something that we want to understand if it is not a value, then it could have a list. Right? Or it could have a hash table, right?
Mighty Jaguar: Instead of this value can be just have value and if it is null, writing it when we can check whether the hash table is empty.
Warm Dingo: Of course, we could have more than one way of flagging them, right. Right. Like we might not have to, I mean, it could be a reference to a list data structure, which would be null or none, it could be a reference to a hash table there but of data structure, which would then allow that we could always check that and then look for a value. And the value could be reference to an object or something, right. And we could have on a wave, particular way to determine whether we have to either go the value path or we have to go the indirection path with a list or hash tag. So with the hash table, what happens is, we need to have a key. So hashtable doesn't give us any order. I mean, unless it is like order hash table, which has some kind of a tree structure to that which gives a range type of lookup. It doesn't give a ordered approach to if you want to iterate it and get it in some iterable format, right? Where in some order hash table, probably a plain hash table doesn't give us that opportunity is right, but it definitely gives us a way to look up that one in an amortized constant time. Right. And once the look up, that one we could jump into the next frame of the same object, next object with the same logical frame of it, where we check for that, whether it is a value or a, or whether it is a list, right? And we go keep going deeper, right? That is one way to look at it, right? If we have a list, it gives us almost the way we maintain the list. It depends, right? If we want to maintain like, sorry, yeah. So if we, if we maintain a list data structure, then maybe it is a little lightweight in compared to a hash table in terms of no amount of library or memory overhead we might have in maintaining the substructure, right, I got just a object, individual object with a reference object, right, so the next one, but then again, with the list the problem will be to check whether there is an existing object with the same key within that pitch doesn't give an opportunity without a lot of iteration. And we also need to make sure to arrive at the policy of what is the order in which objects will be stored in the letter that they will be in any particular key order or just in insertion order. If it has to be in insertion order, whether it is going to be inserted, let us at the beginning or whether it is like latest at the end, whether it's a tail queue, or it is like just the insert at the beginning of a list. We could figure it out. But lists doesn't definitely help us with the like, look up, right, it definitely makes it a little easier to just build it. Right, we might have to think whether we could combine the properties of a list and a hash table if we want. If we want something like a hash table in which we are doing some kind of a, you know, latest look up first, or something like that, we could have a we could have a hash table and know, like a list through the values within the hash table, right? Where in case if you have done a lookup on the hash table, and we want to keep it much later, earlier in the list, we could keep it beginning in the link, we could promote it in the list or something like that.
Mighty Jaguar: So that so this just lets us go with the list. Because a we don't know how they're gonna access it, and we don't care. We can access it, and then we can restructure that or something like that. Because for us, the biggest thing is like we have an XML, and we just need to parse it and make sure that the structure remains, structurally, as it is like, the hierarchy. So that's for now, for time sake, let's keep it this way. Okay.
Warm Dingo: Sure. So, yeah, so, we your suggestion is to use like a list for the data structure rather than hash tables, right?
Mighty Jaguar: So, at this point let's keep it as a list, the reason being, so, what other than, like, the hash table will be listed. Like if I had to just like, you know, iterate over all the elements. For the hash table, like, it might be like, you know, you have a key and then you would be you would have to get the list of keys and then iterate over those list of keys and get the values and those kind of things you can have a using entries and ordering and Python maker using destiny, you can have a DLL at this point, like, if I had to, like do you think you have to structure it in a different way? How would a hash table, what will be the key to the?
Warm Dingo: What would be the keys in the hashtable? The key in a hash table. For example, if we are trying to check for the, for example, if somebody says I want to get the value under a dot b dot c, right, then basically, yeah, so basically.
Mighty Jaguar: As I said, like, the thing that they are talking about, like on line 20, and 21, like, data reduction, we don't care about that, and shorter and shorter. So now, do you think hash table or list?
Warm Dingo: Right, so of course, hash table doesn't suit for this case, because we really do not want to do like a lookup pattern. With something, we just want to be able to represent this XML in a data structure, right? We just want to parse the XML and keep it in a relatable formatting that we so that we could just know what is the structural form in which XML exists, we just want to represent that in some data structure, then hash table is not really required. Okay.
Mighty Jaguar: Now, let's say if I'm going to add that, hey, I gave you the key. And then so let's say I give you a format tokenizer in the format, action and value. So action can be taken. And so whenever there is a token, not just time taken, so it will have times values, and whenever there isn't, and again, the time value and and then the other one is, like value. So you're gonna, like, in this case, y is one of the values just say value. So normally if it is a child one, then you would have this kind of almost like a parent, will begin, and then that would be another begin. So let's say if you had to do this, like, how would you store the actions?
Warm Dingo: So I still have what is the action and value here? Because I understood that begin is like, opening a tag. And it's like closing a tag and whatever is there in between, and this is.
Mighty Jaguar: This is the input and I'm saying like, okay, that is already, someone who, like, there's already a layer, which passed this XML and gave you the same thing in this format. Let's say in a list or something, like a tuple in a list. And, and what do you need to do is pass this to create the object that you're gonna create.
Warm Dingo: Okay. So, so this is the input we are getting right and to me, right, no...
Mighty Jaguar: Moving to a function instead of an action. I'm saying, I'll give you this input.
Warm Dingo: Okay, so we want to form the same data structure with this as an input rather than an XML file, is it something like that, looking at it.
Mighty Jaguar: That mean we get the XML file that is. So here, there's a function that parses that XML file, and it gives you the same thing in this format. And then it just calls your function with that format. And let's say, like, how do you want this format? Like how would you want this input? And, and the input would be basically just a tuple.
Warm Dingo: Action, value, something like that, right?
Mighty Jaguar: Action is what I want to understand. How would you want the action to be?
Warm Dingo: Okay, so trying to understand is, we have an XML file, right? And previously, we wrote a layer to parse XML file and store it the data in some list format, right nested list or something. That's what it's called. And then now we are discussing that we have like a list of tuples, right? And we want to process them and what you're asking is here, what is that we want to specify the action as correct?
Mighty Jaguar: Like what do you create its own class we like to know.
Warm Dingo: So right. So, so, if the idea is set to process this list of tuples and iterate over the data structure we previously created, is that the case?
Mighty Jaguar: The idea is we will be... iterating over the tuple and create the data structure.
Warm Dingo: Okay, okay. Make sense. So make sense. So, the action and a string. So in the same way, we created the data structure using bypassing the XML in the same way, we also want to create the data structure by passing the tuple list off tuples.
Mighty Jaguar: No, no. So what I'm saying is like, previously, we were saying that we will be parsing the XML, but once the parser of that XML gives you this format, how can you give it to a parser and then how do...
Warm Dingo: You have two stages right now, let me write it down like this right. So you have an XML parser right, which is giving you a line interpreted line in bread data as a list of tuples, right? And then instead of converting from XML directly to the data structure, we want to convert it into that nested list type of data structure or whatever and we have this middle layer in between which is generating this line interpreted list of numbers. So now, how do you want so this in reality, the way I would have parsed the XML by using like a stack, right, it's a basic recursive data structure and so, what I would actually do it is like begin and they would be action into the data structure we use whether whether it is going to be push right or a pop for an end right. And something like that, and in between what we have is the actual visit to that to that node. If it is a value, then we find something right. And whatever we have on the stack so far in the path which led to that value which we are visiting, right. Right. And whatever is the object which is at the top of the stack at that point in time should be the running object under which we need to be adding this value. So does that sound familiar enough? Yeah. Okay, so Ah, I mean, of course, for writing this data structure itself, we should use a stack.
Mighty Jaguar: So basically, so when you say push, right? So what is a push?
Warm Dingo: So push, of course, basically results in instantiating a new object, right? And inserting, instantiating a new object with all this has the associated attributes, right, we could have...
Mighty Jaguar: All I'm saying is like, how would you make believe? Like, what do you consider? Begin? Like, there are only three things like begin value and end for action, right, right. Will you give them as a string or will you keep them as something else?
Warm Dingo: Okay, will you keep them as a string? Or will you keep them as? Yeah. So, I mean, that actually trie value to what you just spoke, right. So, that, as this spoke it is going to be, we could just break it down to something like zero. I mean, if we just weren't making the system as robust and as less data intensive as possible, we could just have an integer, which indicates what is the action and logical mapping of that value could be a push or pop in our source code, right.
Mighty Jaguar: So, yeah, I understand that all right. So when I say the present, all I mean is like a data type what data can you use?
Warm Dingo: Okay, so, what is the data type? Would you use right? Okay. So, so, I mean, coming, coming from the system world, so sorry, if I have not interpreted the data type on this, right? So it could be as simple as a string itself, right? Or it could be just an integer. If you're looking at a functional programming kind of thing, then it could be a function object, which is, which has the logic embedded in what means what they are, and it takes care of the argument or the right effect or something like that, right. Yeah, it is totally integrated into implementation dependent on how we want to logically format this whole module.
Mighty Jaguar: How do you because you're writing the functions, how do you want to do it?
Warm Dingo: So if I'm just if I'm parsing the XML data structure using a stack and if I want to create this line interpreted list of tuples, right, then while the find a open tag in the XML, we know that it is a push and the industry to sorry.
Mighty Jaguar: You are still going, like back to again, definitely. I just want to understand whether it should be a string, it should be an integer? That's all.
Warm Dingo: So, I mean, it depends upon how we you use it for parsing the line interpreted tuples, right.
Mighty Jaguar: Whatever you want the line tuples would give you.
Warm Dingo: Yeah, I would, yeah. So, because it's a line interpreted data we are just going we are I mean, whoever is processing this is going to go line by line right? We are going to process this one followed by process this one followed by processing this one, right. Right. So in reality, what we are really looking for is a mapping between what to do right, what to do, and what data is needed to do that. Right. So what to do...
Mighty Jaguar: What to do is what I'm saying is when the couple's first value is and the data that you need is the second value.
Warm Dingo: Exactly right. So what to do we determined that it is either push or visit that basically right? Sorry.
Mighty Jaguar: Again, like going in circles. How do you want that what to do? Like, basically what to do is basically based on what value? What action I'm trying to perform, like whether it's again?
Warm Dingo: Yeah, I could I could just have it in the form of integers, right? For the sake of simplicity, right. So if I want to write raw data here.
Mighty Jaguar: The optimal way is actually no.
Warm Dingo: Yeah, of course. It's I mean, it is a trie value, right. Sorry. It is tria value. So it is of course, having a it's an in, in reality is nothing but 012. Right, it is.
Mighty Jaguar: Yeah, I'm asking for whether you were to use a string on an enum, those kind of things.
Warm Dingo: And when I said you're just try value the implementation, of course, it does boil down to using an enum. Tomorrow somebody if they decide that I have brought in this new type of XML, where it has a new thing not just open closed, then we could just extend the implementation by adding a new enum and corresponding logic under the line interpreter. Enum is the way to go.
Mighty Jaguar: So let's do some coding. Okay. I'll just use this data and fight them in maybe you could just type it up in English.
Warm Dingo: Maybe I could code it up if you are looking up Python.
Mighty Jaguar: Basically, I was just gonna say the same thing that I had here. And then the next one, actually, I just gave as a string.
Warm Dingo: Sure, sure. I can get the data structures, right it is. Right.
Mighty Jaguar: If you want you can start writing.
Warm Dingo: Okay, so basically, you're looking for is some way to interpret it, or basically parse this and do the logical action, right. So you want a function? So you want a function to process this list of?
Mighty Jaguar: Yeah. I'm just calling say hello itself, like, don't do those kind of things. I'm passing this list to say hello.
Warm Dingo: Okay. Yeah. So I can write the code, let's say you call say hello, I can have a helper function, which is like basically parse right? It takes a list, right? I will just call it as data itself. Right?
Mighty Jaguar: Then, so we already have, hello, say, Hello. I was just simply okay.
Warm Dingo: Okay, so, so yeah. So, so basically, you just want me to implement this function, right? And yeah, I could have implemented it in line there. So no issues, right? I could do it here. So the idea is, we want to be able to we have data is nothing but a list of tuples. And we want to parse it and instantiate that data structure or something like that, right. So initially, what we need to be doing is we need to be building need to be able to push it to the stack whatever data we have, first of all right. And we need to process line by line, or each element one at a time, right? So let me think about it like this. So we have a list, which has a length, and then we are going to process it. From zero to len minus one, we need to process it right? And, and, of course, at any point in time we are processing it, processing it, we need to be able to process it with reference to the parent object. Right? That's what I think we need to be doing right? So important thing to do is, of course, the first object is going to be begin, right? It is implicitly positive, right? So what we could do first is to let's say the actual object, which we create is just called a node, right? Y, is equal to node of data of zero, right? Let's just assume that data, zero is a couple that we need to pass to that we have a node created for the root, right? So let's just call it root. So then, what we need to do is on the stack is equal to actually the root object, and we have the data, right? And it begins with at index one, right? So or what I could do is less stack is empty initially stack dot append of the root, right? I could just say that it's a tuple. Now, and I could just have the index from which we need to pass now is is one right? Then we could have while stack, right? Basically, we will process it until the end of the stack, right? So we have node comma index is equal to stack. Okay, this one?
Mighty Jaguar: Why not just use for each?
Warm Dingo: So why not use for each in node, right? So it's kind of a if, if I'm, if I'm just doing for each, right, let's say I am here, we instantiate an object, right? And under that object, we need to instantiate another because we decided that it is going to be like a list, right? So a needs to have be as a child, right?
Mighty Jaguar: And all the stack approaches, right. That's the way I'm doing on line seven. Really So what the one that you have on 10? You're passing the index.
Warm Dingo: Wait. So I understood. So what I am trying to do right now is to have like a root node from which everything else is going to be referred off of right? So, for example, I agree with you, if I just pass it in the form of for each and we look at what is the operation at zero, right? And look at it. And if it is an end, right, then we need to go back to the parent. So that we could, if I just do it, or then how do we go back to the parent? Because if you're just doing for loop, right, because we're not really doing a record to implementation here. If I want to process one more action under the same object, and if you have already terminated a child and define processing, beginning processing of another child, then it has to be done in the parents context, not in the present objects context, which we have just completed processing.
Mighty Jaguar: So, so when you say that I'm trying to ask is, like, let's say you have, you're not instantiating the stack.
Warm Dingo: I mean, I can lose, I ended remember to do a for loop, and we could keep a stack on the side, right, we push it from the stack. And, yeah, that that is also possible, I can do it like that. But usually, what happens is, this is the, this is the recipe I use for any kind of iterative depth first search in leetcode quickly. So I just tend to use that I agree with you, as well. So I can just use a stack. If you ignore everything above, right? Ignore everything above, like the next. So you can ignore everything about that. We could just have a stack here, and then we could do for each for say, action. Or I could just say data, right? Be in data, right? Because some are some time. Oh, it's always a couple. So that's fine. So action comma value in data right? If action let's say is zero, I could just say equal to zero, right? Then we just instantiate a object equal to node of value, right. And yeah, sorry, yeah, I could have done like that, then I just stack dot append of object right. Something like that. And then and we are done with that object at that point in time. Right. And then we go to the next object, right, when we go to the next object. Another important thing probably we need to also is at this point in time, if before we push it into the stack, we might want to make the parents refer to this object as right for example, if stack as an object already at the top right. Is I mean if there is something first of all, it might be empty, if stack, because there are only objects always at the top of the stack, right, what we need to do is stack of minus one right whatever is at the top of the stack, dot whatever functionality we implement the right it could be something like add, add a child, something like that. Add child OBJ right and then we push object on top of the stack. So now we are basically doing an inline referencing of the child objects to the parent. And if else is the elif of action is equal to let's... Say, what was the other one and right? We just need to do stack dot pop in reality, right? Because we are not going to lose the reference of this object because they already made the parent refer to this object, right? Whereas, before we pushed on top of the stack the parent object already referred to that right. And, as right other action is of course, I think what value right. So, in that case, stack minus one dot value equal to the value, right. So, so now at the end, what happens is the old out, lost the reference of the root object itself in case if you just return here, right. So, it is important to make sure that if length of stack equal to one, right, we just need to make sure that we keep a copy of the root is equal to stack or else just to stack dot pop and at the end we could return. Does that... let me check.
Mighty Jaguar: Sorry, yeah, that makes sense.
Warm Dingo: Right, let me just check some scenarios is the data is empty, then, of course, none has taken care and this the data, of course, the data is integral right a beginning and an end so, whatever we are parsing, integrated check is something which could be could have done beforehand before we enter this loop because it would be hard to do an integrated check in once we get into this loop, right? Maybe we need to do an integrity check to make sure that the data is integral and if there is no bug in the XML interpreter to this data, which are getting if it is integral, then we could get into this loop we could do for each processing like this, right. And, in case if there is only the end, the length should always be okay, can the length be oh yeah the length could be easily odd, I believe, right? Not a problem. So if the length is centered, and so I could I can't do any decision based upon the length of the list being given or odd actually. So that is ignorable. I'm just trying to see if there are any he had this handle. Of course, the if the length of the data is unity equal to one then there is definitely something wrong in the data, right? Or it is possible that the parent object itself is nothing but a value right? Then we are not really pushed something when into the stack. And we are trying to check this one here. So there is an issue in case if the data is nothing but let's say only this line, then we have a bug, right. So I think integrated check should have handled it, but we could do it IN O(N) operation before we enter into this loop. Maybe I don't need to handle it here. Right. And in case if it is unity, then we just need to instantiate the object outside this loop and return the root. It has the root for it. That's what probably I will do otherwise in every other scenarios, I think we should be able to handle this in this in this manner.
Mighty Jaguar: So a few questions. I know we are going over time. Let's say this was malformed. What can I say he already given what kind of error message.
Warm Dingo: We would do to the as a outputted. Yeah. And I agree with you. So the return from this functionality, if it is like a public interface to end user application, then in case if you are just returning if the interface is always returning some something like this right? One way is to I don't know how it is actually done in Python because I only use Python for leetcoding in a system word of course, I will have it return the error code. Right and it actually returned by a reference to something, for example, I could be an assembler, I would pass a pointer to a pointer and one or two. And that could be defined in an enum. And we could log it and and normally we throw exceptions. Yeah, it is dependent on or sometimes I worked in C without C++, so there is no exception. So yeah, exception, that's something that we could handle in C++, or any other modern object oriented language we have, we could handle the exception and progress from that point onwards. But in if you're looking at an operating system interface or something, they're usually in case if it's an unhandled exception may result in a trap or some kind of a fault. Okay. So, you will be you will be giving the feedback in like a text form, or you could give it in words. I'm not sure how it actually there's my first intro here.
Mighty Jaguar: So, so yeah. Firstly, getting the design phase. Since you said you had management experience we wanted, normally, people would like to know, how to design certain things and those kind of things. So you went into a type of key value, like, you know, hey, I want to create quickly. But as I said, Before, I just want this structure to be passed into an object. I know, we could have optimized it, we could do a lot of things. But the I mean, for simplicity sake, you should always like, you know, the questions you're asking was right, but basically, you are, again, going into that more reading, like, sometimes it's like, I had to bring you back a lot of times, but no, let's stick to this tag. Let's not go there. So, in the end, who might be there flags are not there, you're not listening. And you're not trying to focus on the things that is? Similar thing would be action. Read, I was asking, like, Okay, how would you store the biggest value, and action? And that's why I said, like, I just wanted the data type. Like, literally said, I wanted data type, right, but you're again, like, you know, what, to what actions we would do those kind of things. Like, I didn't want that. I understood what you wanted to do with them. And that was right. But again, like, going too far, and someone else, if you do that, basically, you're wasting your own time. It's like, you know, moving forward in solution. The communication was good data structure. Usage was optimal. Good job on testing. Like to test in your own code. Those things are good. The according is scored a little bit rusty, but it's good. And yeah, I mean, just try to understand, like, what are exceptions and those kind of things because those are like would be used on some level, and when to use them when not to use them, those kind of things. Other than that, like, yeah, just try to listen to the interviewer. We're the first thing is when I gave you that section, you went directly into like, okay, yeah, we can do it this way. We can do it this way. I would say like, try to if you're not sure. Try to ask more questions, that's okay. That's the gathering page, basically. So you would want to gather information and are like, okay, what is the requirement? What is the same? Take a minute or so to gather and then formulate, so that you get to the optimal solution and what the interviewer is looking for.
Warm Dingo: Yeah, I think sometimes I, when I find that there are so many ways to interpret it, I tried to enumerate all the ways of interpreting it, instead of asking them exactly what you want. That's why it goes into the direction of Okay, you want to do a key value lookup type of thing. I mean, I knew that, of course, I would implement at the end action with an enum. But I was thinking, okay, what exactly is this person asking? The reason I mean, I work in a system world where I look at assembly code, and then C code and VS code. And some of these things we implement by hand. And there are only so many ways of doing it. And this way of doing kind of opening up my myself to these different ways of doing right now. And when I see that, okay, yeah, I mean, there are only a few obvious ways of doing things. Now there are more ways of doing it in. And then upper layer. I seem to give the list of interpretations of it rather than asking what exactly is the interviewer looking for?
Mighty Jaguar: Yeah, don't do that. Like, just ask questions. And then see, it's a collaborative thing. They are basically also looking for collaboration. So ask those questions. Make it much smoother for you. You don't have to use my things. We really don't understand what is going to happen and yeah, other than that, yeah, keep practicing.
Warm Dingo: Thank you. Thank you.
Mighty Jaguar: Hopefully, this was helpful.
Warm Dingo: Yeah, it was helpful. Thanks a lot. Have a great day.
Mighty Jaguar: You too, bye.