gaspersic/coding-interview-university
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Organized one more time. Much better.

Browse Source
This commit is contained in:
John Washam 2016-06-23 14:00:09 -07:00
parent f28fc93dd8
commit 44fddd68ea
1 changed files with 182 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

250
plan.txt
View File

@ -88,7 +88,7 @@ Some videos are available only by enrolling in a Coursera or EdX class. It is fr
* - Google uses clang-format (there is a command line "style" argument: -style=google) * - Google uses clang-format (there is a command line "style" argument: -style=google)
* - Efficiency with Algorithms, Performance with Data Structures: https://youtu.be/fHNmRkzxHWs * - Efficiency with Algorithms, Performance with Data Structures: https://youtu.be/fHNmRkzxHWs
- C++ Core Guidelines: http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines - C++ Core Guidelines: http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines
- review of C++ concepts: https://www.youtube.com/watch?v=Rub-JsjMhWY * - review of C++ concepts: https://www.youtube.com/watch?v=Rub-JsjMhWY
* - compilers: * - compilers:
* - https://class.coursera.org/compilers-004/lecture/1 * - https://class.coursera.org/compilers-004/lecture/1
@ -145,6 +145,11 @@ Then test it out on a computer to make sure it's not buggy from syntax.
- Amortized Analysis: https://www.youtube.com/watch?v=B3SpQZaAZP4&index=10&list=PL1BaGV1cIH4UhkL8a9bJGG356covJ76qN - Amortized Analysis: https://www.youtube.com/watch?v=B3SpQZaAZP4&index=10&list=PL1BaGV1cIH4UhkL8a9bJGG356covJ76qN
- Illustrating "Big O": https://class.coursera.org/algorithmicthink1-004/lecture/63 - Illustrating "Big O": https://class.coursera.org/algorithmicthink1-004/lecture/63
- Cheat sheet: http://bigocheatsheet.com/ - Cheat sheet: http://bigocheatsheet.com/
-----------------------------------------------------
Trees
-----------------------------------------------------
* - Arrays: (Implement an automatically resizing vector) * - Arrays: (Implement an automatically resizing vector)
* - Description: * - Description:
- Arrays: https://www.coursera.org/learn/data-structures/lecture/OsBSF/arrays - Arrays: https://www.coursera.org/learn/data-structures/lecture/OsBSF/arrays
@ -180,6 +185,7 @@ Then test it out on a computer to make sure it's not buggy from syntax.
* - Space * - Space
- contiguous in memory, so proximity helps performance - contiguous in memory, so proximity helps performance
- space needed = (array capacity, which is >= n) * size of item, but even if 2n, still O(n) - space needed = (array capacity, which is >= n) * size of item, but even if 2n, still O(n)
* - Linked Lists * - Linked Lists
* - Description: * - Description:
* - https://www.coursera.org/learn/data-structures/lecture/kHhgK/singly-linked-lists * - https://www.coursera.org/learn/data-structures/lecture/kHhgK/singly-linked-lists
@ -217,12 +223,14 @@ Then test it out on a computer to make sure it's not buggy from syntax.
* - Doubly-linked List * - Doubly-linked List
- Description: https://www.coursera.org/learn/data-structures/lecture/jpGKD/doubly-linked-lists - Description: https://www.coursera.org/learn/data-structures/lecture/jpGKD/doubly-linked-lists
- No need to implement - No need to implement
* - Stacks * - Stacks
* - https://www.coursera.org/learn/data-structures/lecture/UdKzQ/stacks * - https://www.coursera.org/learn/data-structures/lecture/UdKzQ/stacks
* - https://class.coursera.org/algs4partI-010/lecture/18 * - https://class.coursera.org/algs4partI-010/lecture/18
* - https://class.coursera.org/algs4partI-010/lecture/19 * - https://class.coursera.org/algs4partI-010/lecture/19
* - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Using-stacks-last-first-out/149042/177120-4.html * - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Using-stacks-last-first-out/149042/177120-4.html
* - Will not implement. Implementing with array is trivial. * - Will not implement. Implementing with array is trivial.
* - Queues * - Queues
* - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Using-queues-first-first-out/149042/177122-4.html * - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Using-queues-first-first-out/149042/177122-4.html
* - https://class.coursera.org/algs4partI-010/lecture/20 * - https://class.coursera.org/algs4partI-010/lecture/20
@ -245,6 +253,7 @@ Then test it out on a computer to make sure it's not buggy from syntax.
enqueue: O(1) (amortized, linked list and array [probing]) enqueue: O(1) (amortized, linked list and array [probing])
dequeue: O(1) (linked list and array) dequeue: O(1) (linked list and array)
empty: O(1) (linked list and array) empty: O(1) (linked list and array)
* - Hash tables * - Hash tables
* - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Understanding-hash-functions/149042/177126-4.html * - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Understanding-hash-functions/149042/177126-4.html
* - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Using-hash-tables/149042/177127-4.html * - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Using-hash-tables/149042/177127-4.html
@ -271,29 +280,35 @@ Then test it out on a computer to make sure it's not buggy from syntax.
- exists(key) - exists(key)
- get(key) - get(key)
- remove(key) - remove(key)
Tries
- https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/08Xyf/core-introduction-to-tries
Disjoint Sets:
- https://www.coursera.org/learn/data-structures/lecture/JssSY/overview
- https://www.coursera.org/learn/data-structures/lecture/EM5D0/naive-implementations
- https://www.coursera.org/learn/data-structures/lecture/Mxu0w/trees
- https://www.coursera.org/learn/data-structures/lecture/qb4c2/union-by-rank
- https://www.coursera.org/learn/data-structures/lecture/Q9CVI/path-compression
- https://www.coursera.org/learn/data-structures/lecture/GQQLN/analysis-optional
Heap (data structure):
- https://en.wikipedia.org/wiki/Heap_(data_structure)
- https://www.coursera.org/learn/data-structures/lecture/2OpTs/introduction
- https://www.coursera.org/learn/data-structures/lecture/z3l9N/naive-implementations
- https://www.coursera.org/learn/data-structures/lecture/GRV2q/binary-trees
- https://www.coursera.org/learn/data-structures/supplement/S5xxz/tree-height-remark
- https://www.coursera.org/learn/data-structures/lecture/0g1dl/basic-operations
- https://www.coursera.org/learn/data-structures/lecture/gl5Ni/complete-binary-trees
- https://www.coursera.org/learn/data-structures/lecture/HxQo9/pseudocode
- see: https://class.coursera.org/algs4partI-010/lecture -----------------------------------------------------
- https://class.coursera.org/algs4partI-010/lecture/39 More Knowledge
Priority Queue -----------------------------------------------------
- https://en.wikipedia.org/wiki/Priority_queue
- Binary search:
- https://www.youtube.com/watch?v=D5SrAga1pno
- detail: https://www.topcoder.com/community/data-science/data-science-tutorials/binary-search/
- Bit operations
- Get a really good understanding of manipulating bits with: &, |, ^, ~, >>, <<
- https://en.wikipedia.org/wiki/Bit_manipulation
- http://graphics.stanford.edu/~seander/bithacks.html
- http://bits.stephan-brumme.com/
- http://bits.stephan-brumme.com/interactive.html
- count "on" bits
- https://youtu.be/Hzuzo9NJrlc
- https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetKernighan
- http://stackoverflow.com/questions/109023/how-to-count-the-number-of-set-bits-in-a-32-bit-integer
- round to next power of 2:
- http://bits.stephan-brumme.com/roundUpToNextPowerOfTwo.html
- max run of on/off bits
- swap values:
- http://bits.stephan-brumme.com/swap.html
- bit shifting
- https://www.youtube.com/watch?v=Ix9U1qR3c3Q
- absolute value:
- http://bits.stephan-brumme.com/absInteger.html
* - Parity & Hamming Code: * - Parity & Hamming Code:
Parity: Parity:
https://www.youtube.com/watch?v=DdMcAUlxh1M https://www.youtube.com/watch?v=DdMcAUlxh1M
@ -302,43 +317,67 @@ Priority Queue
https://www.youtube.com/watch?v=JAMLuxdHH8o https://www.youtube.com/watch?v=JAMLuxdHH8o
Error Checking: Error Checking:
https://www.youtube.com/watch?v=wbH2VxzmoZk https://www.youtube.com/watch?v=wbH2VxzmoZk
Bit operations
- http://graphics.stanford.edu/~seander/bithacks.html -----------------------------------------------------
- count on bits
- https://youtu.be/Hzuzo9NJrlc
- max run of on/off bits
- bit shifting
Binary search
Sorting
- stability in sorting algorithms:
- http://stackoverflow.com/questions/1517793/stability-in-sorting-algorithms
- http://www.geeksforgeeks.org/stability-in-sorting-algorithms/
- Which algorithms can be used on linked lists? Which on arrays? Which on both? Is Quicksort stable?
- Implement & know best case/worst case, average complexity of each:
- mergesort
- quicksort
- insertion sort
- selection sort
- no bubble sort - it's terrible at O(n^2)
Caches
- LRU cache
Binary trees:
- https://www.coursera.org/learn/data-structures/lecture/GRV2q/binary-trees
Binary Heap:
Min Heap / Max Heap
Trees Trees
-----------------------------------------------------
Notes:
- https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/ovovP/core-trees - https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/ovovP/core-trees
- see: https://class.coursera.org/algs4partI-010/lecture - https://class.coursera.org/algs4partI-010/lecture
- basic tree construction - basic tree construction
- traversal - traversal
- manipulation algorithms - manipulation algorithms
- BFS (breadth-first search)
- DFS (depth-first search)
- know the difference between
- inorder
- postorder
- preorder
- Binary trees:
- https://www.coursera.org/learn/data-structures/lecture/GRV2q/binary-trees
- Binary search trees: BSTs - Binary search trees: BSTs
- https://www.coursera.org/learn/data-structures/lecture/E7cXP/introduction - https://www.coursera.org/learn/data-structures/lecture/E7cXP/introduction
- https://www.youtube.com/watch?v=pYT9F8_LFTM
- applications: - applications:
- https://class.coursera.org/algs4partI-010/lecture/57 - https://class.coursera.org/algs4partI-010/lecture/57
- n-ary trees
- trie-trees - N-ary trees
- at least one type of balanced binary tree (and know how it's implemented): - https://en.wikipedia.org/wiki/K-ary_tree
- Tries
- https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/08Xyf/core-introduction-to-tries
- https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/PvlZW/core-performance-of-tries
- https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/DFvd3/core-implementing-a-trie
- Heap (data structure):
- https://en.wikipedia.org/wiki/Heap_(data_structure)
- https://www.coursera.org/learn/data-structures/lecture/2OpTs/introduction
- https://www.coursera.org/learn/data-structures/lecture/z3l9N/naive-implementations
- https://www.coursera.org/learn/data-structures/lecture/GRV2q/binary-trees
- https://www.coursera.org/learn/data-structures/supplement/S5xxz/tree-height-remark
- https://www.coursera.org/learn/data-structures/lecture/0g1dl/basic-operations
- https://www.coursera.org/learn/data-structures/lecture/gl5Ni/complete-binary-trees
- https://www.coursera.org/learn/data-structures/lecture/HxQo9/pseudocode
- see: https://class.coursera.org/algs4partI-010/lecture
- https://class.coursera.org/algs4partI-010/lecture/39
- Binary Heap:
Min Heap / Max Heap
- Disjoint Sets:
- https://www.coursera.org/learn/data-structures/lecture/JssSY/overview
- https://www.coursera.org/learn/data-structures/lecture/EM5D0/naive-implementations
- https://www.coursera.org/learn/data-structures/lecture/Mxu0w/trees
- https://www.coursera.org/learn/data-structures/lecture/qb4c2/union-by-rank
- https://www.coursera.org/learn/data-structures/lecture/Q9CVI/path-compression
- https://www.coursera.org/learn/data-structures/lecture/GQQLN/analysis-optional
- Priority Queue
- https://en.wikipedia.org/wiki/Priority_queue
Know least one type of balanced binary tree (and know how it's implemented):
- red/black tree - red/black tree
- https://class.coursera.org/algs4partI-010/lecture/50 - https://class.coursera.org/algs4partI-010/lecture/50
- splay trees - splay trees
@ -351,38 +390,80 @@ Trees
- https://class.coursera.org/algs4partI-010/lecture/49 - https://class.coursera.org/algs4partI-010/lecture/49
- B-Trees: - B-Trees:
- https://class.coursera.org/algs4partI-010/lecture/51 - https://class.coursera.org/algs4partI-010/lecture/51
- BFS (breadth-first search)
- DFS (depth-first search) -----------------------------------------------------
- know the difference between Graphs
- inorder -----------------------------------------------------
- postorder Notes:
- preorder
Graphs:
There are three basic ways to represent a graph in memory: There are three basic ways to represent a graph in memory:
- objects and pointers - objects and pointers
- matrix - matrix
- adjacency list - adjacency list
- familiarize yourself with each representation and its pros & cons Familiarize yourself with each representation and its pros & cons
- BFS and DFS - know their computational complexity, their tradeoffs, and how to implement them in real code BFS and DFS - know their computational complexity, their tradeoffs, and how to implement them in real code
- If you get a chance, try to study up on fancier algorithms: If you get a chance, try to study up on fancier algorithms:
- Dijkstra's algorithm - Dijkstra's algorithm
- https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm - https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm
- A* - A*
- https://en.wikipedia.org/wiki/A*_search_algorithm - https://en.wikipedia.org/wiki/A*_search_algorithm
- when asked a question, look for a graph-based solution first, then move on if none. When asked a question, look for a graph-based solution first, then move on if none.
Other data structures:
- You should study up on as many other data structures and algorithms as possible Implement:
- You should especially know about the most famous classes of NP-complete problems, such as traveling salesman
and the knapsack problem, and be able to recognize them when an interviewer asks you them in disguise. Dijkstra's algorithm
A*
You'll get more graph practice in Skiena's book (see Books section below) and the interview books
-----------------------------------------------------
Sorting
-----------------------------------------------------
Notes:
- Implement & know best case/worst case, average complexity of each:
- no bubble sort - it's terrible - O(n^2)
- stability in sorting algorithms:
- http://stackoverflow.com/questions/1517793/stability-in-sorting-algorithms
- http://www.geeksforgeeks.org/stability-in-sorting-algorithms/
- Which algorithms can be used on linked lists? Which on arrays? Which on both? Is Quicksort stable?
Implement:
Mergesort
Quicksort
Insertion Sort
Selection Sort
-----------------------------------------------------
More Knowledge
-----------------------------------------------------
Caches
- LRU cache
NP and NP Complete
- Know about the most famous classes of NP-complete problems, such as traveling salesman and the knapsack problem,
and be able to recognize them when an interviewer asks you them in disguise.
- Know what NP-complete means. - Know what NP-complete means.
Recursion Recursion
- when it is appropriate to use it - when it is appropriate to use it
open-ended problems open-ended problems
- manipulate strings - manipulate strings
- manipulate patterns - manipulate patterns
Combinatorics (n choose k)
Probability
Dynamic Programming
Scheduling Scheduling
Weighted random sampling Weighted random sampling
Implement system routines Implement system routines
Design patterns: Design patterns:
- description: - description:
- https://www.lynda.com/Developer-Programming-Foundations-tutorials/Foundations-Programming-Design-Patterns/135365-2.html - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Foundations-Programming-Design-Patterns/135365-2.html
@ -393,9 +474,7 @@ Design patterns:
- decorator - decorator
- visitor - visitor
- factory - factory
Combinatorics (n choose k)
Probability
Dynamic Programming
Operating Systems (25 videos): Operating Systems (25 videos):
- https://www.youtube.com/watch?v=-KWd_eQYLwY&index=2&list=PL-XXv-cvA_iBDyz-ba4yDskqMDY6A1w_c - https://www.youtube.com/watch?v=-KWd_eQYLwY&index=2&list=PL-XXv-cvA_iBDyz-ba4yDskqMDY6A1w_c
Covers: Covers:
@ -420,9 +499,13 @@ Operating Systems (25 videos):
- threads in C++: - threads in C++:
https://www.youtube.com/playlist?list=PL5jc9xFGsL8E12so1wlMS0r0hTQoJL74M https://www.youtube.com/playlist?list=PL5jc9xFGsL8E12so1wlMS0r0hTQoJL74M
- stopped here: https://www.youtube.com/watch?v=_N0B5ua7oN8&list=PL5jc9xFGsL8E12so1wlMS0r0hTQoJL74M&index=4 - stopped here: https://www.youtube.com/watch?v=_N0B5ua7oN8&list=PL5jc9xFGsL8E12so1wlMS0r0hTQoJL74M&index=4
Data handling:
- see scalability options below
Distill large data sets to single values Distill large data sets to single values
Transform one data set to another Transform one data set to another
Handling obscenely large amounts of data Handling obscenely large amounts of data
System design: System design:
- features sets - features sets
- interfaces - interfaces
@ -430,8 +513,9 @@ System design:
- designing a system under certain constraints - designing a system under certain constraints
- simplicity and robustness - simplicity and robustness
- tradeoffs - tradeoffs
Performance analysis and optimization - performance analysis and optimization
Familiarize yourself with unix-based souped-up code editor: emacs & vi(m)
Familiarize yourself with a unix-based code editor: emacs & vi(m)
vi(m): vi(m):
- https://www.youtube.com/watch?v=5givLEMcINQ&index=1&list=PL13bz4SHGmRxlZVmWQ9DvXo1fEg4UdGkr - https://www.youtube.com/watch?v=5givLEMcINQ&index=1&list=PL13bz4SHGmRxlZVmWQ9DvXo1fEg4UdGkr
- set of 4: - set of 4:
@ -486,6 +570,14 @@ Machine Learning:
Parallel Programming: Parallel Programming:
- https://www.coursera.org/learn/parprog1/home/week/1 - https://www.coursera.org/learn/parprog1/home/week/1
String search algorithm:
Knuth-Morris-Pratt (KMP):
- https://en.wikipedia.org/wiki/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm
- https://www.youtube.com/watch?v=2ogqPWJSftE
Boyer–Moore string search algorithm
- https://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_string_search_algorithm
- https://www.youtube.com/watch?v=xYBM0_dChRE
------------------------ ------------------------
Be thinking of for when the interview comes: Be thinking of for when the interview comes:
@ -513,7 +605,8 @@ Have questions for the interviewer.
Some of mine (I already may know answer to but want their opinion or team perspective): Some of mine (I already may know answer to but want their opinion or team perspective):
- How large is your team? - How large is your team?
- What is your dev cycle look like? Do you do sprints/agile? - What is your dev cycle look like? Do you do waterfall/sprints/agile?
- Are rushes to deadlines common? Or is there flexibility?
- How are decisions made in your team? - How are decisions made in your team?
- How many meetings do you have per week? - How many meetings do you have per week?
- Do you feel your work environment helps you concentrate? - Do you feel your work environment helps you concentrate?
@ -528,7 +621,7 @@ Some of mine (I already may know answer to but want their opinion or team perspe
Mentioned in Coaching: Mentioned in Coaching:
The Algorithm Design Manual The Algorithm Design Manual (Skiena)
- Book (can rent on kindle): http://www.amazon.com/Algorithm-Design-Manual-Steven-Skiena/dp/1849967202 - Book (can rent on kindle): http://www.amazon.com/Algorithm-Design-Manual-Steven-Skiena/dp/1849967202
- Answers: http://www.algorithm.cs.sunysb.edu/algowiki/index.php/The_Algorithms_Design_Manual_(Second_Edition) - Answers: http://www.algorithm.cs.sunysb.edu/algowiki/index.php/The_Algorithms_Design_Manual_(Second_Edition)
@ -553,11 +646,12 @@ Additional (not suggested by Google but I added):
* - C++ Primer Plus, 6th Edition * - C++ Primer Plus, 6th Edition
Introduction to Algorithms Introduction to Algorithms
- https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844
Programming Pearls: Programming Pearls:
- http://www.amazon.com/Programming-Pearls-2nd-Jon-Bentley/dp/0201657880 - http://www.amazon.com/Programming-Pearls-2nd-Jon-Bentley/dp/0201657880
If you see people reference "The Google Resume", it was replaced by "Cracking the Coding Interview". If you see people reference "The Google Resume", it was a book replaced by "Cracking the Coding Interview".
########################################################################################## ##########################################################################################
########################################################################################## ##########################################################################################
@ -572,14 +666,6 @@ Additional (not suggested by Google but I added):
## ##
########################################################################################## ##########################################################################################
String search algorithm:
Knuth-Morris-Pratt (KMP):
- https://en.wikipedia.org/wiki/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm
- https://www.youtube.com/watch?v=2ogqPWJSftE
Boyer–Moore string search algorithm
- https://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_string_search_algorithm
- https://www.youtube.com/watch?v=xYBM0_dChRE
########################################################################################## ##########################################################################################
## Videos: ## Videos:
########################################################################################## ##########################################################################################