Software Engineer Internship Interview Questions

Lets deal with the hour hand first. In 60 minutes (1 hour) the hand travels 5 minutes on the clock face, so in 1 minute it travels 0.0833 minutes on the clock face (5/60). At 3'0clock the hour hand was exactly at 3. After 15 minutes it has moved 0.0833*15 = 1.25 minutes on the clock face. At 3.15 the minute hand is exactly at 3, so the difference between the hour and minute hand is 1.25 minutes. So now we just convert 1.25 minutes into degrees to get the angle between the two hands. We do that with the following logic - in 60 minutes the minute hand turns 360 degrees, so in 1 minute the hand turns 360/60 = 6 degrees, so in 1.25 minutes the hand turns 6*1.25 = 7.5 degrees. This is the angle between the two hands at 3.15

http://en.wikipedia.org/wiki/Clock_angle_problem

You were actually asked to write two versions, one is the recursive one, and the other non-recursive. Then explain why the recursive one is very bad.

int fib_rec(int n) { switch(n) { case 0: return 0; case 1: return 1; } return fib_rec(n-2) + fib_rec(n-1); } int fib_iter(int n) { switch(n) { case 0: return 0; case 1: return 1; } int f0=0; int f1=1; for(int i=2;i<=n;++i) { int f2=f0+f1; f0=f1; f1=f2; } return f1; }

The recursive solution is terrible, because it takes exponential time. The iterative solution isn't bad - this takes O(n) time. It's possible to do O(log n) time using Binet's formula.

C has no class- C is a functional programming language!!!!!

I think you mean difference between class and object in C++, C is a low level language with no Class functionality (it does have struct however). A class is a collection of variables and functions for the purposes of OO programming. An object is an in stance of the class that can call its member functions and variables

Signed can hold positive and negative numbers, unsigned numbers can only hold positive numbers (or 0)

signed value ranges from (-Max_Val, Max_Val), while signed goes from (0, 2*Max_Val). Max_Val is the predefined maximum value for the specific data type. They both have the same range of 2*Max_Val

XOR all the elements together - the result will be the missing number. This works assuming there's only one missing number, but it's the fastest way. If there are multiple missing elements, use a hashtable.

missing = SUM(expected) - SUM(actual) (again works only if 1 no. is missing!)

The naive algorithm will take O(n^2) time, but it is very easy to code. The divide and conquer algorithm will take O(nlgn) time, but a little challenge to implement.

If by "sequential order" you mean that the indices of the numbers in the subsequence must be consecutive, I think this should work in O(n): int main() { int best[N], B, i, a[N]; //input to a; best[0] = a[0]; B = a[0]; for(i = 1; i best[i-1]) best[i] = B + a[i]; else best[i] = best[i-1]; B = max(a[i], B + a[i]); } return best[N-1]; return 0; }

Breadth first search

Detailed analysis and solution are available in the following blog: http://codercareer.blogspot.com/2011/10/no-11-print-binary-trees-from-top-to.html