Engineering Interview Questions

Actually, to add to that, I wouldn't be able to include 8 - 10 terms, as that would rely on the square root operation itself.... so I'd have to rely on a linear approximation.

This is the way to go. Fast inverse square root as used in Quake III. float Q_rsqrt( float number ) { long i; float x2, y; const float threehalfs = 1.5F; x2 = number * 0.5F; y = number; i = * ( long * ) &y; // evil floating point bit level hacking i = 0x5f3759df - ( i >> 1 ); // what the fuck? y = * ( float * ) &i; y = y * ( threehalfs - ( x2 * y * y ) ); // 1st iteration // y = y * ( threehalfs - ( x2 * y * y ) ); // 2nd iteration, this can be removed return y; }

For detailed explanation of the algorithm, see http://en.wikipedia.org/wiki/Fast_inverse_square_root

I wouldn't know about this algorithm, but I can think of a (definitely slower than this one) bisection algorithm to find the root of x^2 = number.

Often what they are looking for is a programming data structures oriented solution. Such as using binary search to find sq root etc.

poop

google_interview = ( [(1, 5), (10, 15), (20, 25) ], (12,27) ) just_insert = ( [(1, 5), (10, 15), (20, 25), (80,89)], (17, 18) ) join_case = ( [(1, 5), (10, 15), (20, 25), (80,89)], (12, 22) ) empty_case = ( [], (1,10) ) def merge(orig,anew): """ If the input items are sorted, and interval is a 2-tuple, create a new list of intervals, such that we join together any overlapping intervals into a single tuple describing the combined range of the two or three tuples that could collide when we merge another interval into a list""" newlist = [] if len(orig)==0: return [anew] n = 0 # get items that are before the join while norig[n][0]: middleitem[0] = orig[n][0] if n=orig[n+1][0] and middleitem[1] middleitem[1]: # print "break",orig[n] break if orig[n][1] > middleitem[1]: # print "extend" middleitem[1] = orig[n][1] # print "skip",orig[n] n = n + 1 # now append remaining items newlist = newlist + [tuple(middleitem)] newlist += orig[n:] return newlist def test(tup): print 'merge( '+repr(tup[0])+', '+ repr(tup[1])+ ' )' print ' -> ', merge(tup[0], tup[1] ) print ' ' print "Test begin" test( google_interview ) test( just_insert ) test( join_case ) test( empty_case ) print "Test end"

n*lgn sorted by lower bound and gogogo scan once.

JAVA CODE: import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; /** * Created by admin on 3/2/16. */ class Interval { int start; int end; Interval() {start = 0;end =0;} Interval(int s, int e) { start = s; end = e; } } public class Solution { public List insert(List intervals, Interval newInterval) { ArrayList result = new ArrayList(); intervals.add(newInterval); return merge(intervals); } public List merge(List intervals) { ArrayList result = new ArrayList(); if (intervals == null || intervals.size() == 0) { return result; } Collections.sort(intervals, new Comparator() { public int compare(Interval a, Interval b) { return a.start - b.start; } }); for (int i=0;i= intervals.get(i+1).start) { current.end = Math.max(current.end, intervals.get(i+1).end); i++; } result.add(current); } return result; } } Time Complexity: nlgn + n = O(nlgn)

int[] mergeDisjointIntervals(int[] intervals, int[] range){ ArrayList result = new ArrayList(); for(int i=0;irange[0]&&high is inside return 0; } else if(lowrange[0]&&high overlaps tail return -1; } else if(low>range[0]&&lowrange[1]){ // 1 -> overlaps head return 1; } else{ // 2 -> does not overlap return 2; } }

int[] mergeDisjointIntervals(int[] intervals, int[] range){ ArrayList result = new ArrayList(); for(int i=0;irange[0]&&high is inside return 0; } else if(lowrange[0]&&high overlaps tail return -1; } else if(low>range[0]&&lowrange[1]){ // 1 -> overlaps head return 1; } else{ // 2 -> does not overlap return 2; } }

why not just a * b^(-1) :-)

// Write a function that divides one number by another, without using the division operator, // Assume that x%y = 0 // O(log n) (function() { 'use strict'; var divide = function(x, y) { var xLength = (x + '').length; var i = 0; var result = 0; var xAry = ('' + x).split(); var xStart = ''; for (i = 1; i = y) { xStart -= y; result = parseInt(result, 10) + 1; } } } return result; }; console.log(divide(1000, 4)); })();

Use logarithms? O(1) log(x/y) = log(x) - log(y) = log(answer) answer = 10 ^ log(answer)

Convert the number to divide into the base of the number that you are dividing with and then shift the 'bits' to the right by 1 then convert back to decimal

All above answers are wrong. You can solve problem via dynamic programming / recursion. Let DP[a][b] be smallest cost of guessing number in worst case if you know that result is in range [a; b]. DP[x][x] = 0 (if range has only 1 element then there is no need of asking a question). DP[a][b] = min( max(DP[a][x-1], DP[x+1][b]) + x ) for all x in range [a; b] Optimal query is the x which gives minimum value for DP[][]. For example: If range is 10 you should try 7 as first guess. If range is 100 you should try 85. If range is 1000 you should try 873. So it is not like there is any best percentage which gives optimal value for any range.

binary search for question 1, Huffman encoding for question 2.

@andrew shouldn't the answer for range [1,1000] be 897 ?

Malik

for word in $(cat paragraph.txt);do echo $word;done|sort|uniq -c|sort -n|tail -3|awk {'print $2'}

Python 2 solution: #!/usr/bin/python import operator with open("paragraph.txt", "r") as fin: text = fin.readlines() words = text[0].split() struct = {} for word in words: if not word in struct.keys(): struct[word] = 1 else: struct[word] += 1 ordered_words = sorted(struct.items(), key=operator.itemgetter(1), reverse=True) for index in ordered_words[0:3]: word = index[0] count = index[1] print word, count

A more correct shell answer, which returns the top word first: for word in `cat input.txt`; do echo $word; done | sort | uniq -c | sort -nr | head -3 | awk '{print $2}'

The solution mentioned above is O(n^2), because for every node, it is comparing value with all the nodes in Vals array. We can do better than this because we have BST, which is in sorted order. (For unsorted Binary tree, we should have sorted first in O(nlogn) and then searched O(nlogn). O(nlogn) solution - Traverse the BST with DFS (O(n)). For each node of value 'a' search for node of value "b = k - a". Searching in BST would be O(logn). Thus the solution becomes O(nlogn)

HashMap tracker = new HashMap(); public SumPair parseTree(Node node, int sum) { if (node == null) { return null; } SumPair pair = parseTree(node.left, sum); if (pair == null) { pair = parseTree(node.right, sum); } if (pair == null) { if (tracker.containsKey(node.data)) { pair = new SumPair(node, tracker.get(node.data)); } else { tracker.put(sum - node.data, node); } } return pair; }

With a node reference to left,right and parent, it can be done in O(n) Start at deep left with 2 node references at lowest node, value L. move one reference in DFS way until it find a node R >= K-L. if equal then we have a L and R then move the first reference to the next value in DFS, until node L > K-R repeat until last node is reached and L + R > K lot of micro-optimization possible (skip a whole node by going direct to parent when the parent is still lower than what we looking for)

Yes

Yes. I have led teams of Engineers and Technicians in the recent past.