Print Human Phone Number with airSlate SignNow

Print human phone number

how's it going guys today we are going to be going over another interview question this interview question is called letter combinations of a phone number this is a pretty popular question from what I understand it looks like it's asked by a lot of companies it's asked by Facebook Google Amazon Microsoft uber JP Morgan and Morgan Stanley the problem description says given a string containing digits from 2 to 9 inclusive returned all possible letter combinations that the number could represent and the mapping of digit to letters just like on the telephone buttons is given below note that one does not map to any letters so we're basically asked like hey given a phone number how many different letter combinations are there and so we're right we're given this kind of like screen that's gonna associate a number with a variety of letters potentially so if we're given the example 2 3 that's our phone number these are the outputs right because a can be represented by the number 2 and then we would go to the number 3 right so we chose a as our mapping for the number 2 now we have to choose a mapping for our number 3 so we choose D so that's one mapping and then another mapping would be a to e right a to 2 and E for 3 AF B DB EB F so on and so forth so this is a good question that's kind of like disguised as like a BFS so what we really want to do here is kind of like take one number so let's say 2 for example and we want to pass we kind of like want to go through all the representations of two so two in this case can be represented as a B or C so we want to take one representation of two so say a and then move on to the next number so in this case it'd be three so now we're passing the string a to this recursive call and then we want to match up that a with all the possible combinations of three so we would get right a D ayyyy and AF as our recursive calls 1 2 & 3 underneath our root for a so that would give us a dae and AF and then we would move on to the next combination or the next representation of a sorry of to or miss speaking so now we've already done a so it would be B right so now we have another thing that we want to hold still so we're holding be still now and now we're gonna go on to the next number which would be 3 again so now we have B and then the three different letters that three can represent are d E and F so those would be the three things underneath that part of the tree so hopefully that's making sense it's a little bit hard to explain it's kind of tricky to think about and it's very kind of like in depth in terms of like recursion but essentially what we're gonna do is for every number we're gonna take every possible representation of that number and then pass that on to all our potential recursive calls that we would have so with that being said it's a little confusing again sorry if it's not a great explanation but hopefully once we write this code it'll be a little bit more clear so we want to return a list of strings that represent all the potential combinations right or all the potential yeah letter combinations is what they're calling it so we just want to make a variable to actually return so I typically will call this thing result so we'll have a list of strings because that's what the function wants we'll call it result and we'll set it equal to a new ArrayList that's gonna hold strings and so now I just like to do error checking so we can do some quick error checking so like if the digits that they give us or know or the length of digits is 0 we have nothing to process right so if that's the case we'll just return our result which is just an empty list in this case otherwise what we want to do is we need right we need some easy way to understand that to maps to a B and C 3 maps to DF 4 maps to GHI so on and so forth so I would propose we just make an array of strings call it mappings so let's do that so string mappings is equal to and then I just kind of like to format it like this and we notice right there is no so 0 doesn't map to anything and 1 doesn't map to anything but just to be consistent with like our indices like to being represented as the second index in our array 0 based I would like to keep kind of like dummy values as a 0 and 1 and XO 0 and 1 will just be nothing but now when we say like mappings of two we want that to map to a b c d e f 4/3 g h i j k l so I'm just going through and doing these mappings MNO and PQRS P qrs tuv T V and then the X W X Y Z cool so now we have our mappings so now we need to kind of come up with a way to do what I was trying to explain before and so I was explaining that like recursively it would be pretty intuitive to do so I personally like to solve problems like this by having like a shell function kind of is like the driver so in this case this is like our shell it's kind of just setting stuff up for us and now we'll call a recursive function that's like in my eyes just kind of like magically gonna give us the answer so we can call this something like let's just do letter combinations recursive nice and simple and this recursive function is going to need a couple things right so it's going to need a result because my idea is like we're just going to call this recursive function it's going to populate the thing that we need to return and then all have to do after is return result and that will be it so all the work is actually gonna be done in this recursive function so we need to pass it results so we can add all the answers to it we need to pass it digits so that it actually those what numbers we're dealing with we need to pass it a string that's going to represent like the current combination that we're dealing with in each recursive call we need to pass it an index like we're in the digits we're currently on like where what number and then we also need to pass it or mappings let's let's actually just call this mapping singular cool so again seems like kind of hand Levy but now this is like where the meat of our program is actually in a B so we'll make our function public void right because it's gonna actually add everything into this list of strings and then we'll just have to return it so it's not going to return anything it's just going to modify our variable called result so it's not gonna return anything we're letter combinations recursive it's gonna take a string I'm sorry a list of strings called result it's going to take a string called digits it's going to take a string we'll call it current because that's the current combination that we're dealing with we're gonna take an integer called index and finally a an array of strings called mapping awesome so that's kind of like a lot function you could kind of clean it up if you wanted to a little bit but this is just one solution so in our recursive calls we're gonna need a base case and in other words we're gonna need a place to know when to stop so we want to stop this recursive function when we have a correct combination and so the way to know if we have a correct combination is basically by the length right so if we've added enough characters then we have a combination so we can just check if our current actually let's do if our index let's just say you can do it either way so you can say if like your current slang is equal to something or let's just do index so if our index in this case is equal to digits that length then we know that we have no other numbers of process right now because we have valid combination so we'll just say result add and we'll say current because that represents our combination and then we'll just return because we don't want to continue but if our index is not equal to our current in any of our recursive calls we need to keep processing our current combination so what we can do now is like what we were saying so we want to get the current mapping and then pass for each of its possibilities so like if we were on to the number we need to pass a B and C to our recursive calls so for the first thing that we want to do is we probably want something like string letters and we'll set that equal to mapping and now we want to get the digit that we're actually at so digits dot care at index minus zero and so this will just basically convert our our number as a string into an integer so if we were looking at right so this will be something like digits of you know the third thing or something might be the number four but four will be a string so minus a zero will just convert it into an integer so that when it's looking for an index and mapping its passing an integer and not actually a string so that takes care of now like we have letters to process and now we need to iterate through them right so for int I equals 0 I is less than letters dot length I plus plus and so now what we want to do is we just want to make a recursive call right so we've now grabbed the letters of the current number the wrong that could be represented by that number so like two again would be ABC and now we just need to make recursive calls passing a and one of them being another one of them and then C in the final one so that's why we're iterating through letters so letters in this case would be something like ABC so now we make a recursive call so we'll say letter combinations recursive and we want to pass results again we want to pass digits right so those things stay the same we want to add to current write letters care flips care at I so now this is actually adding like a or B or C depending on what index we are on in the letters okay so then we also need to pass our index but we need to increment it right so we go to the next letter in our next recursive call or the next number rather and then we just need to pass our mapping so that again we have a way to actually translate the number two to the letters ABC or three to D F that's worth it and I think that should just about do it so again from the top super quickly services like long video but we make something called result that's going to store all the combinations we do some error checking and if there's any problems we just return an empty list then we make a mapping so that we can make sense of all the numbers mapping to all the potential letters that they represent then we call a magical recursive function that's just going to do our work that will actually add the combinations to result so then we just add a return result so now in a recursive function we need to know when to stop so our base case is going to be if our current combination we could do it like this current combination is the length that we want so the length of digits or in this case we have an index so we'll just say if our index is at our last number that they're asking us to use so in this case like if it was two three if our index was one our recursive calls would end and if it is right then we have a valid combination so we add it to result and we return so we don't continue otherwise we want to find the letters that are represented by the current number we're at in digits iterate through all the letters that can possibly represent and then just pass whatever letter were on in letters to our next recursive call and we'll increment our index so that we go to the next letter sorry the next number in digits so let's make sure this works nineteen you sure got a semicolon right cool awesome it works so guys if that was helpful be sure to leave a thumbs up and subscribe I release a video every day so you guys can learn about a new tech interview hopefully this helps you with your preparation yeah good luck on all your interviews and I'll see you guys next time