Python Interview with an Amazon engineer

Watch someone solve the max living people problem in an interview with an Amazon engineer and see the feedback their interviewer left them. Explore this problem and others in our library of interview replays.

Interview Summary

Problem type

Max living people

Interview question

Given a list of people and the years when they were born and died, return the year where the most people are alive concurrently.

Interview Feedback

Feedback about Supreme Enigma (the interviewee)

Advance this person to the next round?

How were their technical skills?

4/4

How was their problem solving ability?

4/4

What about their communication ability?

4/4

Interviewer should continue asking questions and laying out assumptions. Communication and control over programming language is good. It is always good to lay out couple of test cases yourself, don't wait for interviewers to give you that. There are interviewers of all kinds - who get involved into the problem and some who don't give any hints any time during the interview. Most important thing is that they know that you are thinking hard and in the right direction, catching your mistakes along the way.

Feedback about Tea-Smoked Platypus (the interviewer)

Would you want to work with this person?

How excited would you be to work with them?

3/4

How good were the questions?

3/4

How helpful was your interviewer in guiding you to the solution(s)?

3/4

The interviewer was very clear and helpful.

Interview Transcript

Supreme Enigma: Hello.

Tea-Smoked Platypus: Hi, can you hear me?

Supreme Enigma: Yes, I can hear you. Sorry for the delay. Okay. All right. So I like to just lay out the format of the interview. And if you have anything that you would like to actually practice on, you can let me know. And we can, I'll try to actually ask question accordingly.

Tea-Smoked Platypus: Okay, so I'm looking for algorithms and data structure mock, any kind. I'm targeting L4 positions. Okay. Yeah. And I'll be coding in Python.

Supreme Enigma: Alright, that's all right. Okay, so. All right, I have a question for you. So before we actually go into the into questions, do you want to do any behavioral type questions or we can just dive right into the question?

Tea-Smoked Platypus: Let's dive into the question.

Supreme Enigma: Okay. Sounds good. So you can see the screen.

Tea-Smoked Platypus: Yeah, I can see the screen.

Supreme Enigma: Okay, so the question is that you're given, and you'd have a lot of flexibility in this question. So you know, if you have any, any questions that you want to ask, you can ask them. And we can actually solve this problem together, I just want to see how we solve it. So the question is that, you're given a set of data. Let's suppose that... suppose that x y, z person who was born in 1960, and who died in 2010. And then there's another ABC who were born in 1960. And died in 1970. Consider that, more data like that, DEF GHI that say that this is 2001 and 2009, and died in 2014 15. And then somebody was born in 2010. And then died in 2020. So this is the input data that you're given. And what you're expected to find out is the year in which most number of people are alive.

Tea-Smoked Platypus: So the name do not matter, right?

Supreme Enigma: The name wouldn't matter, but you're free to approach that as you want. If you don't want to stay with the name, that's all fine.

Tea-Smoked Platypus: Okay. So let's, how many people are we? Are we having?

Supreme Enigma: Well, you can actually think consider that to be within the range of integer.

Tea-Smoked Platypus: Okay. It's going to be an array of integers. And died, it's always larger than or equal to born, right?

Supreme Enigma: That's correct.

Tea-Smoked Platypus: So let's say if it's if they are equal, then does it count as being alive?

Supreme Enigma: Yes, you will count that person was alive on in that year.

Tea-Smoked Platypus: But let's say like, in year two, like born and died at the same time, and we still counted as alive.

Supreme Enigma: Yes, you still count that in the year two, there was one person alive. Okay. Good question.

Tea-Smoked Platypus: So in this example, let's see when we are at one, so let's say that like if we sort this list by born and died, we what we have is 1960. And then 1970 then 1960, and then 2010. And then 2009. And 2015 and 2020. Okay, we need to find a year, right? Not like the number of people that are most alive in some year?

Supreme Enigma: Yes, you just need to find the year in which most number of people are alive.

Tea-Smoked Platypus: So, is it safe to assume that like, it's within the maximum and like minimum number of people that we have?

Supreme Enigma: Pretty reasonable limit to like integers? Yeah, even consider them as integers. And let's suppose to make it simple, they are all between 1900 to 2020.

Tea-Smoked Platypus: Okay. I mean, if that's the case, then we just need like, one scan from the beginning, from from the first year to dig in and find out. Like, so for example, if from, from that, if we start at 1960, for example, in this example, and number of people increased by one. And another 1960. So, now it's like two and then 1970. We have one, because one person died. And, and in 19... like in 2009, we have two people, 2010 one people died. And then we have another people born. And I'm also in 2020, Oh, 2015. We have one died. So it's 1, 2020 on person zero. So in this case, do we return this number or this number? Or this number?

Supreme Enigma: Good question, so if you have 1960, I think it's the same as two. So if you have yours, which have equal number of people alive, you can return any of them.

Tea-Smoked Platypus: Okay. Just looking at constraints. Okay. So, I'm thinking like, a, if we like for each year, let's say, we count how many persons like died or how many person was born that year. So each year we have like two properties, basically. And we can just scan through the years and like we we scan through each year and keep track of the most, I keep track of the number of people alive, currently. And then like get the max and return that.

Supreme Enigma: Okay, so what do you think would be the complexity of that particular problem space and time.

Tea-Smoked Platypus: So to process like to basically to preprocess will take less than input, it's like, n people and processing, would take O(n) time and space. Actually, would it be... it would be like rough, actually O(2*n) space because each person, like assuming there's no duplication in terms of the years, and then each person will have like a born date here. And so it's O(2*n) for space. And later on, when we scan through all the years, it's again through the years, probably O(2*n) as well. So, in summary, it's going to take O(n) space, and O(n) time.

Supreme Enigma: So can you actually walk me through your approach? And then we can actually confirm your complexity accordingly?

Tea-Smoked Platypus: Yeah, so previously, I mentioned like sorting, but I don't think it's needed. So, for example, let's say we have like a hashmap. And with all the years that we have 1960, 1970, 2010, 2010, 2015, 2020. Right, and there are two attributes. So let's say the first one. We could be like more clear, until like, b for born and d for died. Okay. Yeah, for sure. And so we know that two person were born in 1960, when we go through the list, so like, here's like two and no one got here. So 0, 1 person died.

Supreme Enigma: Basically one quick question, you are only creating, you are only considering the years that are given in the input for your keys in the hashmap. Right?

Tea-Smoked Platypus: That might change later, but for now. For now, I think only these would be necessary. But okay. Yeah. So, because we assumed that the years are between, like, these two numbers, so we can do a scan between these number and find out. But I don't think that's necessary, but I'll say more about that case later. Let me finish this example. Yes, but one person was born here for like one and then one died, no one died. This year. Like one person born, one person died. 2015, one person died. 2020 one person died. So if we go through the years in a clock, like, increasing time, we have to then it t minus one, it's one and then one plus one is one. This is one plus one minus one is one. One minus one is 0. I did something wrong.

Supreme Enigma: So one plus one, two, and then that will be two plus one minus one. And then I get the idea and good. Okay, so my question is, when this looks actually a good approach, like you're considering all the years that have given him the input, and then you are laying out a row, but on those particular years, how many people were alive? Now my question is, how do you create this kind of data? How do you actually, yeah, we just could scan through this and know that, you know, there were two people born in 1960, because we can see through our eyes, but we have to do with algorithmically somehow.

Tea-Smoked Platypus: Right to go there to a. Right, right. So there are two ways right? First, is we actually... So let's keep going I write the code for the.

Supreme Enigma: Yeah, go ahead.

Tea-Smoked Platypus: Actually, let's not do it. So we can just go through the lists, right, and then like, create a hashmap and add the year in as we as we proceed. So, so something like four more than died in let's say the inputs its input, for example. And then you have like a hashmap. So, if you go through all the items in inputs, you have this hashmap similar to what I have here.

Supreme Enigma: So basically, you get the born and died from you get the you get that particular year, born and die. And then the hashmap. Okay.

Tea-Smoked Platypus: So here, I'm assuming that at that, the inputs come as like array, even though like arrays of tuples like this, like, but but in the beginning, you were saying like you have some data structure, like this way. So can you like, like, tell me like they what is the desired input that you want? So at first, you said you have something that looks like this. But when I process I was assuming having...

Supreme Enigma: Yeah, that's totally fine. We input a few we want to have this very open ended in that case. And I could actually understand from your code, you're like, this is how you're building you're basically you are taking the input that you have is in this format, right. So you are getting born and die from these, considering this is the born here and died here and you basically append the debt or the bond from the so this actually sounds pretty reasonable to me. So now actually, we have something like this and what to do. I get this book pre processing. But now what we want to do is get this part. So let's work on that.

Tea-Smoked Platypus: Okay. Did you just cut that?

Supreme Enigma: No, I didn't sorry. It might have been, I don't know, I didn't type anything.

Tea-Smoked Platypus: I don't know if someone like hacking into this.

Supreme Enigma: So, that might be it if hearing you speak something.

Tea-Smoked Platypus: Okay, I think so, when we spoke, so, we need to go through the years in a sorted order, basically. And one way to do this is to have like a years array, and actually, how to set and when we add the years from the input, we can add the years into the setup, set up ad born. And what it will automatically like discard the duplicates, right? So then, later on, we can create like a array from that, so like, and then we can go through the years in order. So for year in years, let's say the current that we have is zero. So answers like the year. And if we go through the year in order we and a life it's equal to n alive plus... see how many was born that year, and then crease by how many were cited that you? Actually Actually, so here's one thing because for the case that we discussed when the when did you use one of our equal we we still count as one right. So right? So then we need to check the result immediately in that year before we do the subtraction. So if an alife is larger than the max life then update max life to be an alive answer to be the current year. And then so we update and alive include to life to try... But yeah, I don't think like when we subtract, we would need to update the... we would need to update the result when we subtract we only need to do resulting when we add. So when we out the loop we can just return and can we actually...

Supreme Enigma: Can you describe your thought about if the year is same for birth and death. We want the count to increase. So I can see that you are actually doing that when you do online 58 you do that. And we do not want the count to decrease in that case.

Tea-Smoked Platypus: So, actually, actually, what I mean, yeah, you're right, actually, we need to update it a long way. So if alive larger than max alive dissipate. So that is mostly because these two are independent. Like the subtraction and addition, it's independent from the alive. So we need to check it along the way, anyhow.

Supreme Enigma: Okay, I see what you're trying to do. So yeah, are you adding? Number one? And you see, if you actually get the count increased, which I guess in most of most of the times, you will actually have it increased. And then you actually subtract the number of deaths, and then try again. But this might not be so useful, because I'm, I'm hoping that this is always greater than whatever answer this is gonna give us. The problem might actually occur when you actually go into the next iteration. And the count that you wanted to take. I mean, if you will be fine, because you probably want to actually consider the person that in the last year, and then go forward with computing your number of alive for the next particular iteration, if that makes sense. Let's look a little bit. So yeah, go ahead. And you will, you will think something.

Tea-Smoked Platypus: Could you give me an example of the case that you are thinking?

Supreme Enigma: Yeah, let's actually build it up together. So let's suppose we have somebody dying and one one and died on the same year. And let's have something like that. 2001 2002. If you want more for... Okay, let's let's try to see what the answer should be for this.

Tea-Smoked Platypus: Sorry, this one, like this, right?

Supreme Enigma: Oh, yeah. Yep. 2000 digits from for your 1991 1999 there was one person alive for 2000. That person died sometime in 2000. So he was alive in actually in 2000. And this guy was alive in 2000. was alive in 2002. After three years, and in 2001 we have...

Tea-Smoked Platypus: So that person died in 2000. Right. But then this person also died in 2000. Okay, this one was born in 2000. So we have two born. Correct? I see then, like, one carry on from that. Okay. So, got it.

Supreme Enigma: And then 2001... We are just having two people in there. And then 2002 we have 1.

Tea-Smoked Platypus: 2001 it's two because two person died from this one. Yeah, so that's actually one person who got who died in 2001. So you have to live in 2001 and then one person was born in 2001. So, actually, this person died, this person died. So two died, right. And then this person I say was born... Okay, so, but next one, it's...

Supreme Enigma: Yeah, you need to subtract Okay. Well, actually, they never had an intersection would be this person. And this one. And maybe you know, they might not have an intersection. But for simplicity and incompleteness of the input that we have, you can consider that they will always have an intersection, if the that were on the one year is the same of two different people.

Tea-Smoked Platypus: So, so what do you want me to do?

Supreme Enigma: Okay, so let's actually try to build this together, because you're doing very well. And the approach that you have taken is very close to a good solution. But let's actually think, Okay, let's go back to that example that you have. So what you have done is actually layout. Let's use this example and build what you have here and see if we can actually algorithm to map the requirements. So this is how it looks like. Copy this over. Okay, so you want for 1999? Let's lay out all the years, right, that's what you wanted to do. 2000 to 2001 us how you did on that one. And again, now, we can start building up using this example that will actually clarify the picture for you. So how would you you can take it over from here.

Tea-Smoked Platypus: Okay, yeah. Let me take it over. So, right. So, there was all the one person bar this and then two person was born in 2000, and like, two persons died in 2000. 2001, we have one more and one died. And 2002 and one died okay, so. So currently, like, the current number, people are like zero, start, right? And born to like, one, then one plus two. And then we get max. And then like, we update, and it's now 2000. And then we subtract two from three, the person died. Right? So then next one person was born. So one plus one is two. And, and it's two 2000. And then one person died. So two, one is one is one. Next one, no one was born and one person died. And 2000. And one minus one is zero.

Supreme Enigma: For the year 2000. For... Oh, yeah, it's actually correct. Sorry, go ahead. Yes, so moving on to the three because this is what we are looking for. The answers the year right. The answer is the year sorry. 2000. Yeah. Okay. So this is looking good, actually your process good. And we can talk about optimization and complexity afterwards. Do you want to code this up?

Tea-Smoked Platypus: Sure. Okay, can we... Oh, wow. Okay. So let me do def year. Most of life and inputs are like... tuple. And then like when when we call this tuple if we can do like assert test case that we... Alright, so we first need to hashmaps so and we need to import so from collections and we go through the year so for...

Supreme Enigma: So one quick question actually. I mean, you were actually already touching on this but you said that we need some kind of sorting. So, do you want to think about where you want to implement that?

Tea-Smoked Platypus: Oh yeah, so... So actually, I don't think we need sorting. We just need to keep track of the maximum and minimum maximum then we can go from minimum to maximum... Yeah. So previously, here is what a sorting happen without I don't think we needed...

Supreme Enigma: Which line are you pointing to? 50. Okay. All right, I see for you have done it last time you thought did the years and then for all the years you were actually implementing... actually what is I did not read this line last time we written had written down but I think you will require sorting your writing the first thought because otherwise, what else do you actually suggest? If you do not thought what is your alternate solution?

Tea-Smoked Platypus: Yeah, so if we do not start we just need to keep track of the min year and max year. So like when we go through the years in total let me just do it now as well. So max year's like we can put zero and then mid year... Max year and then min year, we can put like because an N 21. This we know that... Yeah. Alright, so for alive in people kind of in min year and born. So born it's always less than died. We don't we don't need to like take the min between born and died and then same for max year. So okay. And we also need to construct or on the and so then later on, we can just go from min year, year in range to max year, really two plus one because it's exclusive. And current, alive at zero. And it's zero. So as we go alive to many people were born this year. And then we checked the max international life larger than alive and much alive took her life and and it's going to be the year and we do the same thing for I guess we probably could do could have like a function to do dissipate as well to avoid like copy and pasting code.

Supreme Enigma: That's all right.

Tea-Smoked Platypus: Yeah. And equal to here. And so finally we return, so for that case. Good. I want to have another test case. So this one should return I think it's going to return like the first one. Like the first few the most people because it doesn't update when the numbers are equal so 1960 that's the real one. Okay, so let's go through this code to see if there's any problem. If the input is empty, then what do you want to return?

Supreme Enigma: Then you can actually throw an exception or you can just consider for example, that input will never be empty.

Tea-Smoked Platypus: Okay. Sounds good. If there's one item in the input came in here next year. I think this will work.

Supreme Enigma: Okay, so let's do it on your example.

Tea-Smoked Platypus: The subject test attribute on your test... tuple not callable. This is where perhaps you're missing a comma. Yes. I'm missing a comma here. We can also print out why print out 2010, this case. So the first one is correct.

Supreme Enigma: I mean, 2010 is also one of the correct answers.

Tea-Smoked Platypus: Yeah, but it shouldn't be updating. Let me see. To double check out print out the year and number life. So if for a life larger than zero, then print. This is problem three. Like year. Okay, so max, three 2000 to 2001. So like there was one point in 2001, before we in the second test case.

Supreme Enigma: So in 2010, there was one point when there were three people alive, because this guy, this guy, and this guy, all three of them should have I should have been alive in 2010.

Tea-Smoked Platypus: Sorry, I'm, I guess you're talking about like the second case, right? I'm looking at the the first case. I don't know why. Yeah, I don't see why like, 2001. Oh, nevermind, like current alive. It's correct. Most alive. It's also correct. Yeah. And 2010. So what's the confusion? Maybe I can help. So, based on my, I don't see why it's, it does, like, update the answer. When, when the current alive, it's less than max alive in 2010. So you're now talking about the second case, right? Yes. So let's think about what are the possible solutions can there be. 1960 to 70? out of question, because we only have like, two people in there. And that 2009 we might have had only maybe one person, then 2000. Or sorry, two people actually there also. And in 2010, this guy was born. So we got an additional person in there. So that's why the answer query only applies to 2010 here. Okay, so somewhere. So yeah, maybe we got over testcase entirety or when we were analyzing her, we might have done take but this is correct according to the requirements that you know, we are considering the death here, also as person being alive in that year. You might have been talking here in before we actually called it up, we might have considered something differently. Okay, one thing. I'm not clear about this, and this is something that I was talking earlier to, like why do we have to make this check this particular thing 21 to 23 line.

Supreme Enigma: So, okay, let's see if let's say this. This didn't happen, assuming that didn't happen. Assuming that didn't happen, and something didn't happen. Sorry. So in this one we fo people, then it might be it could be higher than max alive. If we subtract if we subtract, then it will be lower. But could it? Could there be any case where we haven't reached that number? Haven't reached the max?

Tea-Smoked Platypus: That is not positive. Right. If you maximize one anytime that you probably actually read it here itself.

Supreme Enigma: Yeah. Yeah, I think you're right.

Tea-Smoked Platypus: We didn't see it change anything. So, this condition, yep. 2010 and two tough. Alright, wonderful. I mean, we have few more minutes. I actually thought we started late, because I joined in late. Just want to see your thought on what, how would you model this if suppose the input had the year null none for a person who hasn't died yet?

Supreme Enigma: A person who has not died yet? So then, like, we, if that is the case, then in the processing it if die is not none, that we do that, otherwise, we do need to, we do not need to do that. And so another thing is, we need to go to like the current year. Like we don't, like, let's assume that we have like, we need to have like some number that is larger than or equal to like the max. And in this case, and we can go through that. Like, if we output a number, a number, like not inside input, would that be okay?

Tea-Smoked Platypus: Sorry, I did not get the question.

Supreme Enigma: Okay, so let's say the current year is 2020. Can we output that number? If it's not in the input?

Tea-Smoked Platypus: Yes, you can. In that case, it's possible that you will and you can you will have that number or you can actually also have the last largest number that is there. Because I guess they will.

Supreme Enigma: Yeah, so I can just like get the match number and then like increase one from there and see.

Tea-Smoked Platypus: Yep. So I mean, what do you have right now it's a team would also work that person. It's not the we do not actually increase the counter of die. For and that would give us a count. Good count. So let's try this one. Let's do let's do that. We actually get the year 2000. Then only marginally over to here and through here. Tall and 11? Feel one more guy here. Okay, so the answer here should be 2000. And let's do one more. Okay, now we definitely have to have an 11 s answer because we take the first one, and we do not update it. So this, this one is alive in 2011. This one alive and this one are live. So let's try and see if you're going to throw dry run on eight.

Supreme Enigma: Oh, I see. So I was calling min and max on that. So the null is on the border that case, right? Yeah. And, okay. Once you... I think we also need to update the max. Because previously, I was assuming that born is always larger than that it is always larger than or equal to born, but sometimes we don't have the year, the date year, so immediately here as well.

Tea-Smoked Platypus: Okay. Awesome. Yeah. That's what sounds like we're looking for. Okay, so let's talk about complexity again. So let's first talk about time complexity.

Supreme Enigma: Let's not or let's talk about time complexity?

Tea-Smoked Platypus: Let's, let's talk about time complexity first.

Supreme Enigma: Okay. Alright, so this will be proportional to the numbers of people that we have an input. So, yeah, this is O of n right here. And when we go through the years, it It depends on the min year and max year that we have in the input. But let's assume that the min year, it's like, both both of you at the boundaries that we have before. So 1990s sorry. Let's assume that the min years it's always like 1900 and the max year is always 2020. And this, this is like, independent of n. So this has constant runtime. So overall, it's O(n).

Tea-Smoked Platypus: Okay, n it's the number of people. Yes. All right. So if if we have, I mean, when you actually really were actually describing this, you, you would say that the complexity is O(n). And plus, let's suppose your range of scale, right? Okay, so O(n) you think this is constant, that's why it can be considered depending on the number of people in the input. Okay, that's reasonable. Let's talk about space complexity.

Supreme Enigma: Space complexity. We need a hashmap. And for all the years and so it's actually O(k). For a hashmap and each would have to attribute so two times k. The time range. So you can say O(k), for space.

Tea-Smoked Platypus: Okay, sounds good. All right, those are, I think the right answers. And this is where we can actually conclude our interview. But there's also one more point I want to make that you can actually optimize this a little bit more on the space, because now you actually, basically a complexities of K, you can actually bring it down to off to 2n. And it might seem like, you know, off K is not such a big number. But depending on how the input is, you don't have to actually calculate, calculate this particular value for all the years, you just have to calculate it for the each year in question.

Supreme Enigma: Yeah, but what if like, we have a million person?

Tea-Smoked Platypus: I mean, you, you don't really know how the inputs are. So both of them are valid on so I'm not gonna say that this is the right approach. And that is not. But usually, like, we would not want to calculate for all the years because they those that data is not helpful to our calculation.

Supreme Enigma: But in terms of like space complexity, we know that k is constant. And, n could grow arbitrarily. So an average K is, I think it's better than n.

Tea-Smoked Platypus: Okay. That might be better in that case here. Okay. So that brings us to the end of the interview, we'll do at least quick feedback, both ways and sign off. So let me first actually start, I feel that you have asked the right questions. And then you actually, before even started coding, you knew, you know, things that could actually do things that really, were not clear, they were trying to add them up before you started coding, I helped you in a couple of places, but I think you were almost there. So you didn't need my help. So that's a good thing. One suggestion I would give is that, if you get stuck, I just communicate, you know, if at a particular point of time in the interview, I wasn't sure if you want to me to help you, or you're thinking about something and you want to be silent. So just let the interviewer know what, what is in your mind. And you're very good at communication, and no complaints on that part. This is actually a very tricky question. Because you know, it's very easy to when you think about it, there are multiple ways to do it, you actually started off thinking on a very solid approach, the other bases are not so optimized. So that was a good start. And then you can actually also figure out how to not thought, which is also an additional benefit, I really appreciate that, then the good thing is that you had the test ready. And there was a point where you probably were not able to understand why it's getting updated to a different value than you were expecting. And you had your mind there. So that's a good thing that viewers can see. All those feedback, I think, are very standard. I like that you actually write to your assumptions. There were few assumptions that were not actually written down or asked like, you know, when I had brought into this into the question that you know, sometimes a person cannot even die and then you should, you should probably model it by ourselves with our interviewer telling. So those are those kinds of cases also good to handle. Yeah, I think you did, you did really well. You have good command over language. You when you have think thought about something you can actually type it out fast which is really helpful in the interview, which are timed. So that's all my feedback. If you have any feedback I can do to actually improve interviewing. Welcome that as well.

Supreme Enigma: I think overall, like you were very clear in terms of communications, and guiding me through the whole interview process. The example was clear as well. And you were very like detailed in terms of like some parts like I was kind of confused, but then like you were pressing on that part, and asking why I write such a piece of code, etc. So I think that's a good point. And you had like different follow ups and ask for space and time complexity and how to optimize. So I think that was helpful. And I didn't feel like pressures when I talked to you, as well. But yeah, I said, I might be. Go ahead, quit. Sorry. So. Yeah, so I think overall, it's good. There was some some silence. That I don't know, like, I don't know like, what what do you want it? So that is, but that just like a few, one or two minutes, and something?

Tea-Smoked Platypus: Okay, got it. Okay, so you've been really well, I wish you best of luck for your future interviews. And just be confident as you are you doing very well.

Supreme Enigma: Okay, thanks a lot. So are you like, Can Can we ask? Can I ask them some questions? Follow up? Yeah, so are you doing mock interviews for people frequently? Or because it's a part of your job or why you're doing this?

Tea-Smoked Platypus: It's not part of my job. I actually worked in Seattle in a company have. This is more like me, just being in touch with programming, because I don't really interview with companies anymore. So I mean, what I see.

Supreme Enigma: So how many years of experience do you have?

Tea-Smoked Platypus: I have, in total, I think four and a half years of programming experience. And then a couple of years of quality assurance experience.

Supreme Enigma: Sorry, a couple of years?

Tea-Smoked Platypus: Of QA testing.

Supreme Enigma: Testing. Okay, I see. I see. So are you like a senior now?

Tea-Smoked Platypus: No, I'm actually software engineer level two. So it's like L5.

Supreme Enigma: Okay, I see. Let's see. Yeah, so I'm sorry thing for L4 I don't know if, if you have any suggestions?

Tea-Smoked Platypus: I think you're doing very well. You're doing very well. I think, no matter what happens in the interview, don't give up. Because, you know, sometimes you get the answer in the last five minutes. And that turns around the interview completely. So just keep trying, listen to the listen to your interviewer. They're always giving you hints. And I mean, no matter how you think, interview, interviewers are judging you, they really want you to succeed because it makes their life easy. If you succeed. So just remember that in your mind, don't unconscious or things like that don't stress out. I know these interviews are really stressful. Like everybody goes through them, but just you know. Stay faithful to yourself, and trust yourself. And you should be fine.

Supreme Enigma: Yeah, I appreciate that. Thanks a lot.

Tea-Smoked Platypus: Okay. Thank you so much for interviewing with me today. And you have a good day.

Supreme Enigma: Oh, nice. Thanks a lot for taking the time. I'm in Seattle as well. Okay. Yeah. And you haven't?

Tea-Smoked Platypus: Actually, if you want to share yours, we can do that after after this interview. I think there will be an option to do that.

Supreme Enigma: Oh, in the platform, we can do that.

Tea-Smoked Platypus: Yes, the once when you actually, you know, when we exit this, there will be a feedback form. And you can actually you mentioned there if you share your contact or not so via email addresses.

Supreme Enigma: Okay, okay. Got it. This is my first time so I didn't know that. Thanks for letting me know.

Tea-Smoked Platypus: Yeah, sure. All right. Good night.

Supreme Enigma: Good night.