Fine, if you don't know, then you don't know. As part of your interview prep is to
There are also many great books, and online blogs and forums that provide great interview questions.
One of these books is Programming interview Exposed.
These are a few notes on it:
Chapter 1, 2:
- Sanitise online profiles.
- Sanitise CV.
Chapter 3: Approaches to Programming Problems.
- Talk through questions before starting to write.
- Write: function or method, class definition or a sequence of related code modules.
- Brush up on the languages you expect to use and write you best code.
- If you mention a technology, make sure you have brushed up on it.
- During the interview demonstrate:
- logical thought process.
- knowledgeable about computers.
- communication skills.
- Solving questions
- Make sure to understand the problem.
- Once you understand, try an example to solidify your understanding.
- Focus on the algorithm and talk throught the process.
- Explain the solution to the interviewer.
- While coding, explain what you’re doing.
- Ask questions.
- Trace through code with an example.
- Check for errors, special cases and boundary conditions.
- When stuck
- Maintain interest and keep trying to solve it.
- Go back to an example.
- Try a different data structure.
- Consider a less-commonly used or more advance aspects of language.
- Analyzing your solution
- Understanding of big-O analysis.
1. Big-O Analysis.
Example: Consider a simple function that returns the maximum value stored in an array of non-negative numbers.
- input size = n (find out what n means in terms of the input). ex. number of elements in an array.
- times the input items is examined (what does examine mean). ex. compare two array values.
- when the comparison is done once for each element. O(n).
- when comparison of one to all. O(n2).
Procedure:
1. Figure out what the input is what n represents.
2. Express the number of operations the algorithm performs in terms of n.
3. Eliminate all but the highest-order terms.
4. Remove all constant factors.
Chapter 4: Linked Lists
Programmer Competencies Matrix on Data structure (More on this in another Post):
2n (Level 0)
|
n2 (Level 1)
|
n (Level 2)
|
log(n) (Level 3)
|
Doesn't know the difference between Array and LinkedList
|
Able to explain and use Arrays, LinkedLists, Dictionaries etc in practical programming tasks
|
Knows space and time tradeoffs of the basic data structures, Arrays vs LinkedLists, Able to explain how hash tables can be implemented and can handle collisions, Priority queues and ways to implement them etc.
|
Knowledge of advanced data structures like B-trees, binomial and fibonacci heaps, AVL/Red Black trees, Splay Trees, Skip Lists, tries etc.
|
There are three basic kinds of linked list:
- singly-linked lists - linear list where each element has a next pointer (link) to the next element.
- can be traversed only in the forward direction.
- need a pointer to the first element (head) of the list.
- first element (head), last element (tail).
- doubly-linked lists - list where each element has a next and previous pointer.
- can be traversed in either direction.
- can be traversed from any element.
- circularly-linked
- no head or tail.
- primary traversal problem - cycle avoidance.
Basic Linked List Operations:
- tracking head element - always keep track of the head element
- traversing the list - always check for the end of the list.
- inserting or deleting list elements - use to pointer for the element and previous element.
A stack is a LIFO data structure and a particular kind of abstract datatype or collection.
It is restricted because a limited number of operations can be implemented and these happend at one end of the stack, the top.
Operations:
Push
Pop
Top or peek
No comments:
Post a Comment