Software development engineer Interview Questions

Good

That's crazy to ask such questions - it takes 2 hours to implement. Probably, interviewers ask them when they want the candidate to fail.

I even can't post the answer - it shows that it exceeded the limit.

public void Reverse() { Link cur = head; Link prev = null; Link temp = null; while (cur != null) { temp = cur.next; cur.next = prev; prev = cur; cur = temp; } tail = head; head = prev; }

Public void reverse() { Node prevNode = null; Node focusNode = head; Node nextNode = head.next; while (nextNode != null) { focusNode.next = prevNode; prevNode = focusNode; focusNode = nextNode; nextNode = nextNode.next; } focusNode.next = prevNode; head = focusNode;

public void reverse(){ let currentNode = head; let previousNode = null; while(currentNode){ let nextNode = currentNode.next; currentNode.next = previousNode; previousNode = currentNode; currentNode = nextNode; } return previousNode; }

Any DFS would do the trick. Don't forget to label visited nodes!

One of the two simplest, most straightforward ways: - Depth-First search (http://en.wikipedia.org/wiki/Depth-first_search) - Breadth-First search (http://en.wikipedia.org/wiki/Breadth-first_search) If your maze is very, very long and deep, and has loops and crazies, and is complicated, I suggest the A* algorithm, which is the industry standard pathfinding algorithm which combines a Breadth-First search with heuristics...sort of like an "intelligent breadth-first search". See http://stackoverflow.com/questions/3097556/programming-theory-solve- a-maze?answertab=active#tab-top

Replace the maze with nodes at intersections and then perform A*

I honestly had no idea how to solve this in a reasonable amount of time.

HashMap map = new HashMap(); for(String str : strings) { Integer count = map.get(str) map.put(str, count != null ? count + 1: new Integer(1) ); } // then iterate through map to find the largest integer, the key will be the string with the most occurances

Its a similar answer to above, but I think using just a hash table is not correct if there is collision. Perfect hashing can be used for no collision, or an array in the hashmap.

Initialize two variables which will the first and second elements in the array respectively. As you loop, if current value is less than both then update both, if it's between the two then only update second.

Here is my python code solution def TwoSmallest(lst): tmp_list = [lst[0],lst[1]] for i in xrange(2,len(lst)): maxi=max(tmp_list[0],tmp_list[1]) if lst[i] < maxi : tmp_list.remove(maxi) tmp_list.append(lst[i]) return tmp_list

If currVal < smallest, 2ndSmallest = smallest and smallest = currVal else if currVal < 2ndSmallest, 2ndSmallest = currVal

void reverse(String *str) { char *end = str; char temp; if (str) { end++; } end--; while (str

Same as the other solution posted, but Java. public String reverse(String str) { char[] arr = str.toCharArray(); int j = arr.length-1; for(int i=0;i

You could have used merge sort.

code in main: public static void main(String[] args) { LinkList newList = new LinkList(); newList.insertFirst(1, 10); newList.insertFirst(2, 30); newList.insertFirst(3, 20); newList.insertFirst(4, 40); newList.displayList(); Link current = newList.first; LinkList result = new LinkList(); LinkList ans = new LinkList(); ans = newList.sort(current, result); ans.displayList(); } recursive method: public LinkList sort(Link current, LinkList result) { Link current_res = result.first; Link previous = result.first; int count = 0; while(current_res != null) { if(current_res.dData >= current.dData) { if(current_res == result.first) { Link newLink = new Link(current.iData, current.dData); newLink.next = result.first; result.first = newLink; count++; break; } else { Link newLink = new Link(current.iData, current.dData); previous.next = newLink; newLink.next = current_res; count++; break; } } previous = current_res; current_res = current_res.next; } if(count == 0) { Link newLink = new Link(current.iData, current.dData); if(previous != null) previous.next = newLink; else { newLink.next = result.first; result.first = newLink; } } current = current.next; if(current == null) { return result; } else { sort(current, result); } return result; }