Developer Interview Questions

sorry u need to give input ;) ------ len(re.findall('[a-zA-Z]', "The quick brown fox jumps over the lazy dog"))

It depends on what has to be considered a word. For example, if we consider a word any string between spaces, we can write it in a more compact way: public static int countWords(String str){ if(str == null || str.isEmpty()) return 0; return str.split(" ").length; }

The question is how to count the characters in the string. If we can assume that the input is ASCII - always clarify first - then we know that the character range is 0-255. void count(char* str, int counts[255]) { if (str == 0) return; if (counts == 0) return; for (char *c = str; c != 0; c++) { counts[*c]++; } } First we assert the input is valid. Note that we take an additional parameter - an array of the count of each ASCII character. We loop through the string until we reach the null terminator, and we iterate a char pointer through each character in the string. For each iteration, we increment the counter in the array. Memory complexity is O(1), runtime complexity is O(n). If the input must be unicode, then we may consider alternatively using a hash table. void count(wchar_t* str, std::unordered_map& counts) { if (str == 0) return; for (char *c = str; c != 0; c++) { counts[*c]++; } } We still arrive at an O(1) memory complexity and O(n) runtime complexity (although it is worth noting that despite a hash table lookup takes O(1) like an array, the fixed cost of each lookup is higher for the hash table due to the hashing function, and in the worst case a lookup can be O(n)).

The question asks to count the characters, without using String.length() you can do this: public static Pair countLetters(String s) { //If the string is null or it is empty then it will have no character if (s == null || s.isEmpty()) { //So return the pair with 0 and 0 return new Pair(0, 0); } //If we should still run the loop. boolean run = true; //The count of characters int count = 0; //The count of characters without spaces int countWithoutSpace = 0; //While we are still running (we are at a valid index) while (run) { //Then try to try { //Get the character at the current count char c = s.charAt(count); //Add one to the count as we have a valid character count++; //If the character is not a space if (c != ' ') { //Then add one to the count without spaces. countWithoutSpace++; } //If we get a StringIndexOutOfBooundsException it means that the current count is outside the length of the string. } catch (StringIndexOutOfBoundsException e) { //So stop the loop. run = false; } } //And return the pair with the count and the count without spaces. return new Pair(count, countWithoutSpace); } This returns both the count with and without spaces and does not use a built in length function.

Wait..Am I missing something? string.Length will do the job?

Yeah i think string.length() will do the job.

failed! String.length returns the length of the String. Google asked you how many letters - in other words you cannot count the spaces. String. length returns number of unicode characters -and so includes spaces

I would do this: public static int countWords(String sentence){ String noSpace; //REMOVE SPACE noSpace = sentence.replaceAll(" ", ""); return noSpace.length }

And in javascript var str = "The quick brown fox jumps over the lazy dog" ; var length = str.replace(/\s/g, "").length;

Its a hashmap. It never guarantees you the order in which you inserted the elements...!!

@ankush: this is where LinkedHashMap comes into play.

An easier one would be to sort the array and since they are asking for the first unique element return the first element that does not appear more than once in the newly sorted array.

@ankush: That does not matter, you do not need to keep the order in the hash map. You go again through the original array, so you definitely find the first unique value. The hashmap is just for bookkeeping.

@kabajiegara: No, that will not work, consider array "2 1" - if you sort, you'll have "1 2" and would thus return 1, which is the wrong answer because the first unique is 2.

Summation(i=0,floor(n/2))[(n-i)C(i)]. I'm sure this can be further simplified though.

Correction on the above: Summation(i=0,floor(n/2))[(n-i)P(i)].

Summation(i=0,floor(n/2))[(n-i)C(i)] is correct. I need to sleep. Sorry.

In C++: string excelNumber(int i) { string excelStr = ""; int numAs = i / 26; int rest = i % 26; for (int j = 0; j < numAs; ++j) { excelStr += "A"; } return excelStr + (char) (rest + 64); } Not sure what is meant to happen for error cases (e.g. 0).

void calc_ord(int ord, char* out) { if (ord == 0) return; int tmp = ord; char *ptr = out; while (tmp <= 26) { *ptr++ = 'A'; tmp -= 26; } *ptr++ = 'A' + tmp; }

public String getName(int n) { String ret=""; while(n>0) { char c='A'+(n%26); ret=c+ret; n/=26; } return ret; }

here in OBJC. Is interesting that no one in the previous answers, is calculating the base system..everyone is hardcoding 26. - (NSString *)lettersFromOrdinal:(NSUInteger)ordinal { NSMutableString *letters = [NSMutableString new]; NSUInteger base = 'Z'-'A'+1; NSUInteger labelLength = ceil(customLog(base, ordinal)); for (NSInteger i = labelLength-1; i >= 0; i--) { NSUInteger pow_ = pow(base, i); NSUInteger res = ordinal/pow_; char letter = 'A' + res - 1; [letters appendFormat:@"%c", letter]; ordinal -= res*pow_; } return [letters copy]; }

In jj's solution, emptying a Max Heap would take O(nlogn) time (basically, the same idea as Heap Sort). Using that time complexity you can use any sorting algorithm that has O(nlogn) time, and then go through the sorted array and check that it only contains consecutive numbers starting with 1. In James' solution, we will need O(n) memory to check for duplicates, to do it in O(n) time. That can also be described as a kind of counting sort. Try and sort the array using counting sort where we expect each element's count to be exactly 1, and in the range [1, n].

We know that sum of numbers from 1 to N is N*(N+1)/2. First we make this calculation and then we sum the numbers in the array. If these two sum.s are equal to each other then the answer is yes, else no. This is an easy O(n) solution.

Put the array in a Set (storing the sum of the numbers in a sum int as well). Step 1 check whether N*(N+1)/2 holds. If it this holds, iterate from 1 to n checking the number is there or not in the set.

kilicars, your solution is badly wrong. Assuming an array of N elements, I could have n-1 elements equal to 0 and just one element equal to n * (n-1) / 2. Your algorithm would say yes

bit lenghty but 1)both 3 & 5l are empty. 2) fill 3l, pour in 5l, fill 3l again and pour in 5l, you'll have 1 l in 3 l. now pour this 1l somewhere then fill 3l one more time.

Add 2 full measures using the 5l, remove 2 full measures with the 3l, you are left with 4l.

Fill full water in the 5 litre canister, remove 3 liters of it to the 5 litre to the 3 litre canister. Keep remaining in the 5 litre canister(=2 litre) somwhere. Take another 5 litre water and perform the same procedure.= another 2 litre... 2+2 =4 litre.. done.

Fill full water in the 5 litre canister, remove 3 liters of it to the 5 litre to the 3 litre canister. Keep remaining in the 5 litre canister(=2 litre) somwhere. Take another 5 litre water and perform the same procedure.= another 2 litre... 2+2 =4 litre.. done.

Sorry guys. none of the above is correct. You forgot the check on the sentence, as Interviewer may be lying or not (50% probability for each of the two). If he is NOT lying than there is NO price behind B --> you have 50% it is behind A and 50% it is behind C. If he IS lying than price is behind door B (100% sure) If you draw the brances tree and put it all together, you have that: Probab. = 0,5*[(0.5*A+0.5*C] + 0.5*1*B Ossia: Probab = 0,25*A + 0.25*C + 0.5B which means that both A and C have 25% probabiity of having it right, while B has 50% to be right. Therefore answer is: "you leave door A and choose door B ". Not because this IS behind door B, but because you have a higher probability this is there. :-)

my vote is with Rob. this is covered in every basic probability and statistics course. I think Andrea is bringing unneeded complexity to the question

Filippo's answer would be correct if he did actually open the door when he chose door A, but because it doesn't say that. So assuming that he telling the truth and that door B does not have a prize i.e probability of a zero, door C must have a probability of 2/3 . Therefore Rob's answer is correct.