Software Engineer Interview Questions in San Jose, CA

May be Stack , any one please correct me if I am wrong.

This can be implemented by using two different stacks, one for back and one for forward.

Command Pattern

it has to do with decrement or condition clause in for loop

n= 20 for (i=0;-i

n= 20 for (i=0;i

static String convert(String sentence, int numberOfRows) { char[] arr = sentence.toCharArray(); String ret = ""; if(numberOfRows == 1) return sentence; int repeatPattern = numberOfRows + (numberOfRows - 2); for(int i = 0; i < numberOfRows; i++){ int s = i; do{ ret += String.valueOf(arr[s]); if(i < numberOfRows - 1 ) { s = s + repeatPattern; } else s = s + numberOfRows + (numberOfRows - 2); }while(s < arr.length); repeatPattern -= 2; } return ret; }

void convert(String s,int r){ int len=s.length(); ArrayList> allLine=new ArrayList>(); for(int i=0;i line=new ArrayList(); allLine.add(line);} int row=0,i=0; while(i0 && i

static String convert_al(String text, int nRows) { char [] char_array = text.toCharArray(); StringBuffer []array = new StringBuffer[nRows]; for(int i=0;i0 && i

The probability of N bits being changed is (1/2)^N. The reason: the number of bits that will change depends on the position of the first zero that appears in the number. If the first zero is at the LSB, only one bit changes; if it is in the third position, the three bits upto the first zero change. Now, it boils down to the probability of finding the first zero. Assuming that the zeros and ones appear with equal probability in a given number, the probability of finding the first 0 in the Nth position is (1/2)^N. For more, look up the Geometric Random Variable.

I think that you need to take into account that if you want to toggle 2 bits, you can only do if you flip bits from position 0..30. Toggling bit 31 is only going to toggle this bit no matter what. Therefore, you need to multiply (33-N)/32 to your proposed result, to keep this into account.

@Mythreya's analysis is correct but incomplete. To get the expected value, you have to multiply the number of bits by their probability. Answer is Sigma{k/(2^k)} for k = 1 to 32.

There is a trick that need global variable or static variable to record the temper sum. so the function declaration cannot be same as loop version if don't use global or static variable. the output parameter b will be the reverse result. void rev(int d, int& b) { b *= 10; if (d/10 == 0) b += d; else { b += d%10; rev(d/10, b); } }

You can do it without the golbal or static variables: int f(int num) { if((num/10) == 0) return num; else return ( 10(num%10) + f(num/10) ); }

Sorry my answer previously posted was wrong. Here is the correct one without golbal or static variables, which is basically the same as the first one by Paul. inf f(int num, int car=0) { car *=10; if((num/10) == 0) return ( car + num ); else return f(num/10, car+(num%10) ); }

First Sort 100 words and keep the hash of sorted words.. Now when you recieve a word, SOrt it and check if Hash contains that key. O(nlogn) Where n is length of String.

Hi I think you can take a look at the most efficient algorithm for this question in this link www.crackeasily.com/2012/01/find-whether-2-strings-are-anagrams.html

To say what MW said more clearly: If you sort words that are the same anagram they will always look the same. Example: "god" and "dog" both look like "dgo". So you sort the input word, then you iterate through the list of 100 words, and while looking at each word sort that word. compare if the input and that word are the same. If they are then you have found an anagram. if you made it to the end of the list and you haven't found an anagram then an anagram does not exist in the list.

String reverse(String s){ int length = s.length()-1 String s1 = "" while (length >= 0){ s1 = s1 + s[length] length-- } return s1 }

forget semicolumns (;), sorry

Push char by char on a stack then concatenate all the pops until the stack is empty.