diff --git a/README.md b/README.md index 4ea8fa2..04db439 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,882 @@ -# Project 9894 +# Google Interview University +*(formerly known as Project 9894)* -This is a setup for this project, which is stealthy right now. Will add more detail soon. +### What is it? + +This is my multi-month study plan for going from web developer (self-taught, no CS degree) to +Google software engineer. Don't let that offend you if you are a web developer. I'm speaking +from my experience, not yours. + + This long list has been extracted and expanded from Google's coaching notes, so these are the things + you need to know. There are extras at the bottom, but this is the list. No shortcuts. + +## Why use it? + +I'm following this plan to prepare for my Google interview. I've been building the web, building +services, and launching startups since 1997. I have an economics degree, not a CS degree. I've +been very successful in my career, but I want to work at Google. I want to progress into larger systems +and get a real understanding of computer systems, algorithmic efficiency, data structure performance, +low-level languages, and how it all works. And if you don't know any of it, Google won't hire you. + +When I started this I didn't know a stack from a heap, didn't know Big-O anything, anything about trees, or how to +traverse a graph. If I had to code a sorting algorithm, I can tell ya it wouldn't have been very good. +Every data structure I've ever used was built in to the language, and I didn't know how they worked +under the hood at all. I've never had to manage memory, unless a process I was running would give an "out of +memory" error, and then I'd have to find a workaround. I've used a few multi-dimensional arrays in my life and +thousands of associative arrays, but I've never created data structures from scratch. + +But after going through this study plan I have high confidence I'll be hired. It's a long plan. It's going to take me +months. If you are familiar with a lot of this already it will take you a lot less time. + +### How to use it + +Everything below is an outline, and you should tackle the items in order from top to bottom. + +I'm using Github's special markdown flavor, including tasks lists to check my progress. + +I check each task box at the beginning of a line when I'm done with it. When all sub-items in a block are done, +I put [x] at the top level, meaning the entire block is done. Sorry you have to remove all my [x] markings +to use this the same way. If you search/replace, just replace [x] with [ ]. +Sometimes I just put a [x] at top level if I know I've done all the subtasks, to cut down on clutter. + +More about Github flavored markdown: https://guides.github.com/features/mastering-markdown/#GitHub-flavored-markdown + +## Interview Process & General Interview Prep + +- [x] Videos: + - [x] https://www.youtube.com/watch?v=oWbUtlUhwa8&feature=youtu.be + - [x] https://www.youtube.com/watch?v=qc1owf2-220&feature=youtu.be + - [x] https://www.youtube.com/watch?v=8npJLXkcmu8 + +- [x] Articles: + - [x] http://www.google.com/about/careers/lifeatgoogle/hiringprocess/ + - [x] http://steve-yegge.blogspot.com/2008/03/get-that-job-at-google.html + - all the things he mentions that you need to know are listed below + - [x] (very dated) http://dondodge.typepad.com/the_next_big_thing/2010/09/how-to-get-a-job-at-google-interview-questions-hiring-process.html + - [x] http://sites.google.com/site/steveyegge2/five-essential-phone-screen-questions + +- [x] Additional (not suggested by Google but I added): + - [x] https://medium.com/always-be-coding/abc-always-be-coding-d5f8051afce2#.4heg8zvm4 + - [x] https://medium.com/always-be-coding/four-steps-to-google-without-a-degree-8f381aa6bd5e#.asalo1vfx + - [x] https://medium.com/@dpup/whiteboarding-4df873dbba2e#.hf6jn45g1 + - [x] http://www.kpcb.com/blog/lessons-learned-how-google-thinks-about-hiring-management-and-culture + - [x] http://www.coderust.com/blog/2014/04/10/effective-whiteboarding-during-programming-interviews/ + - [x] Cracking The Coding Interview Set 1: + - [x] https://www.youtube.com/watch?v=rEJzOhC5ZtQ + - [x] https://www.youtube.com/watch?v=aClxtDcdpsQ + - [x] How to Get a Job at the Big 4: + - [x] https://www.youtube.com/watch?v=YJZCUhxNCv8 + - [x] http://alexbowe.com/failing-at-google-interviews/ + + +## Prerequisite Knowledge + +This short section were prerequisites/interesting info I wanted to learn before getting started on the daily plan. + +You need to know C, C++, or Java to do the coding part of the interview. +They will sometimes make an exception and let you use Python or some other language, but the language +must be mainstream and allow you write your code low-level enough to solve the problems. +You'll see some C, C++ learning included below. + +There are a few books involved, see the bottom. + +Some videos are available only by enrolling in a Coursera or EdX class. It is free to do so. + +- [x] **How computers process a program:** + - [x] https://www.youtube.com/watch?v=42KTvGYQYnA + - [x] https://www.youtube.com/watch?v=Mv2XQgpbTNE + +- [x] **How floating point numbers are stored:** + - [x] simple 8-bit: http://math.stackexchange.com/questions/301435/fractions-in-binary + - [x] 32 bit: https://www.youtube.com/watch?v=ji3SfClm8TU + - [x] 64 bit: https://www.youtube.com/watch?v=50ZYcZebIec + +- [x] **Computer Arch Intro:** + (first video only - interesting but not required) https://www.youtube.com/watch?v=zLP_X4wyHbY&list=PL5PHm2jkkXmi5CxxI7b3JCL1TWybTDtKq&index=1 + +- [x] **C** + - [x] K&R C book (ANSI C) + - [x] Clang: https://www.youtube.com/watch?v=U3zCxnj2w8M + - [x] GDB: + - https://www.youtube.com/watch?v=USPvePv1uzE + - https://www.youtube.com/watch?v=y5JmQItfFck + - Valgrind: https://www.youtube.com/watch?v=fvTsFjDuag8 +- [x] **C++** + - [x] basics + - [x] pointers + - [x] functions + - [x] references + - [x] templates + - [x] compilation + - [x] scope & linkage + - [x] namespaces + - [x] OOP + - [x] STL + - [x] functors: http://www.cprogramming.com/tutorial/functors-function-objects-in-c++.html + - [x] C++ at Google: https://www.youtube.com/watch?v=NOCElcMcFik + - [x] Google C++ Style Guide: https://google.github.io/styleguide/cppguide.html + - [x] Google uses clang-format (there is a command line "style" argument: -style=google) + - [x] Efficiency with Algorithms, Performance with Data Structures: https://youtu.be/fHNmRkzxHWs + - [x] review of C++ concepts: https://www.youtube.com/watch?v=Rub-JsjMhWY + +- **Python** + - I've already use Python quite a bit. This is just for review. + - [ ] https://www.youtube.com/watch?v=N4mEzFDjqtA + +- [x] **Compilers** + - [x] https://class.coursera.org/compilers-004/lecture/1 + - [x] https://class.coursera.org/compilers-004/lecture/2 + - [x] C++: https://www.youtube.com/watch?v=twodd1KFfGk + - [x] Understanding Compiler Optimization (C++): https://www.youtube.com/watch?v=FnGCDLhaxKU + + +## The Daily Plan: + +Each subject does not require a whole day to be able to understand it fully, and you can do multiple of these in a day. + +Each day I take one subject from the list below, watch videos about that subject, and write an implementation in: + C - using structs and functions that take a struct * and something else as args. + C++ - without using built-in types + C++ - using built-in types, like STL's std::list for a linked list + Python - using built-in types (to keep practicing Python) + and write tests to ensure I'm doing it right, sometimes just using simple assert() statements + You may do Java or something else, this is just my thing. + +Why code in all of these? + Practice, practice, practice, until I'm sick of it, and can do it with no problem (some have many edge cases and bookkeeping details to remember) + Work within the raw constraints (allocating/freeing memory without help of garbage collection (except Python)) + Make use of built-in types so I have experience using the built-in tools for real-world use (not going to write my own linked list implementation in production) + +I may not have time to do all of these for every subject, but I'll try. + +You don't need to memorize the guts of every algorithm. + +Write code on a whiteboard, not a computer. Test with some sample inputs. +Then test it out on a computer to make sure it's not buggy from syntax. + + +- [x] **Before you get started:** + - The myth of the Genius Programmer: https://www.youtube.com/watch?v=0SARbwvhupQ + - Google engineers are smart, but many have an insecurity that they aren't smart enough. + +- [x] **Algorithmic complexity / Big O / Asymptotic analysis** + - nothing to implement + - Harvard CS50 - Asymptotic Notation: https://www.youtube.com/watch?v=iOq5kSKqeR4 + - Big O Notations (general quick tutorial) - https://www.youtube.com/watch?v=V6mKVRU1evU + - Big O Notation (and Omega and Theta) - best mathematical explanation: + - https://www.youtube.com/watch?v=ei-A_wy5Yxw&index=2&list=PL1BaGV1cIH4UhkL8a9bJGG356covJ76qN + - Skiena: + - video: https://www.youtube.com/watch?v=gSyDMtdPNpU&index=2&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b + - slides: http://www3.cs.stonybrook.edu/~algorith/video-lectures/2007/lecture2.pdf + - A Gentle Introduction to Algorithm Complexity Analysis: http://discrete.gr/complexity/ + - Orders of Growth: https://class.coursera.org/algorithmicthink1-004/lecture/59 + - Asymptotics: https://class.coursera.org/algorithmicthink1-004/lecture/61 + - UC Berkeley Big O: https://youtu.be/VIS4YDpuP98 + - UC Berkeley Big Omega: https://youtu.be/ca3e7UVmeUc + - Amortized Analysis: https://www.youtube.com/watch?v=B3SpQZaAZP4&index=10&list=PL1BaGV1cIH4UhkL8a9bJGG356covJ76qN + - Illustrating "Big O": https://class.coursera.org/algorithmicthink1-004/lecture/63 + - Cheat sheet: http://bigocheatsheet.com/ + +## Data Structures + +- [x] **Arrays: (Implement an automatically resizing vector)** + - [x] Description: + - Arrays: https://www.coursera.org/learn/data-structures/lecture/OsBSF/arrays + - Arrays: https://www.lynda.com/Developer-Programming-Foundations-tutorials/Basic-arrays/149042/177104-4.html + - Multi-dim: https://www.lynda.com/Developer-Programming-Foundations-tutorials/Multidimensional-arrays/149042/177105-4.html + - Dynamic Arrays: https://www.coursera.org/learn/data-structures/lecture/EwbnV/dynamic-arrays + - Jagged: https://www.lynda.com/Developer-Programming-Foundations-tutorials/Jagged-arrays/149042/177106-4.html + - Resizing arrays: + - https://class.coursera.org/algs4partI-010/lecture/19 + - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Resizable-arrays/149042/177108-4.html + - [x] Implement a vector (mutable array with automatic resizing): + - [x] Practice coding using arrays and pointers, and pointer math to jump to an index instead of using indexing. + - [x] new raw data array with allocated memory + - can allocate int array under the hood, just not use its features + - start with 16, or if starting number is greater, use power of 2 - 16, 32, 64, 128 + - [x] size() - number of items + - [x] capacity() - number of items it can hold + - [x] is_empty() + - [x] at(index) - returns item at given index, blows up if index out of bounds + - [x] push(item) + - [x] insert(index, item) - inserts item at index, shifts that index's value and trailing elements to the right + - [x] prepend(item) - can use insert above at index 0 + - [x] pop() - remove from end, return value + - [x] delete(index) - delete item at index, shifting all trailing elements left + - [x] remove(item) - looks for value and removes index holding it (even if in multiple places) + - [x] find(item) - looks for value and returns first index with that value, -1 if not found + - [x] resize(new_capacity) // private function + - when you reach capacity, resize to double the size + - when popping an item, if size is 1/4 of capacity, resize to half + - [x] Time + - O(1) to add/remove at end (amortized for allocations for more space), index, or update + - O(n) to insert/remove elsewhere + - [x] Space + - contiguous in memory, so proximity helps performance + - space needed = (array capacity, which is >= n) * size of item, but even if 2n, still O(n) + +- [x] **Linked Lists** + - [x] Description: + - [x] https://www.coursera.org/learn/data-structures/lecture/kHhgK/singly-linked-lists + - [x] Lynda.com: + - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Introduction-lists/149042/177115-4.html + - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Understanding-basic-list-implementations/149042/177116-4.html + - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Using-singly-doubly-linked-lists/149042/177117-4.html + - https://www.lynda.com/Developer-Programming-Foundations-tutorials/List-support-across-languages/149042/177118-4.html + - [x] C Code: https://www.youtube.com/watch?v=QN6FPiD0Gzo + - not the whole video, just portions about Node struct and memory allocation. + - [x] Linked List vs Arrays: + - https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/rjBs9/core-linked-lists-vs-arrays + - https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/QUaUd/in-the-real-world-lists-vs-arrays + - [x] why you should avoid linked lists: + - https://www.youtube.com/watch?v=YQs6IC-vgmo + - [x] Gotcha: you need pointer to pointer knowledge: + (for when you pass a pointer to a function that may change the address where that pointer points) + This page is just to get a grasp on ptr to ptr. I don't recommend this list traversal style. Readability and maintainability suffer due to cleverness. + - https://www.eskimo.com/~scs/cclass/int/sx8.html + - [x] implement (I did with tail pointer & without): + - [x] size() - returns number of data elements in list + - [x] empty() - bool returns true if empty + - [x] value_at(index) - returns the value of the nth item (starting at 0 for first) + - [x] push_front(value) - adds an item to the front of the list + - [x] pop_front() - remove front item and return its value + - [x] push_back(value) - adds an item at the end + - [x] pop_back() - removes end item and returns its value + - [x] front() - get value of front item + - [x] back() - get value of end item + - [x] insert(index, value) - insert value at index, so current item at that index is pointed to by new item at index + - [x] erase(index) - removes node at given index + - [x] value_n_from_end(n) - returns the value of the node at nth position from the end of the list + - [x] reverse() - reverses the list + - [x] remove_value(value) - removes the first item in the list with this value + - [x] Doubly-linked List + - Description: https://www.coursera.org/learn/data-structures/lecture/jpGKD/doubly-linked-lists + - No need to implement + +- [x] **Stack** + - [x] https://www.coursera.org/learn/data-structures/lecture/UdKzQ/stacks + - [x] https://class.coursera.org/algs4partI-010/lecture/18 + - [x] https://class.coursera.org/algs4partI-010/lecture/19 + - [x] https://www.lynda.com/Developer-Programming-Foundations-tutorials/Using-stacks-last-first-out/149042/177120-4.html + - [x] Will not implement. Implementing with array is trivial. + +- [x] **Queue** + - [x] https://www.lynda.com/Developer-Programming-Foundations-tutorials/Using-queues-first-first-out/149042/177122-4.html + - [x] https://class.coursera.org/algs4partI-010/lecture/20 + - [x] https://www.coursera.org/learn/data-structures/lecture/EShpq/queue + - [x] Circular buffer/FIFO: https://en.wikipedia.org/wiki/Circular_buffer + - [x] https://class.coursera.org/algs4partI-010/lecture/23 + - [x] https://www.lynda.com/Developer-Programming-Foundations-tutorials/Priority-queues-deques/149042/177123-4.html + - [x] Implement using linked-list, with tail pointer: + - enqueue(value) - adds value at position at tail + - dequeue() - returns value and removes least recently added element (front) + - empty() + - [x] Implement using fixed-sized array: + - enqueue(value) - adds item at end of available storage + - dequeue() - returns value and removes least recently added element + - empty() + - full() + - [x] Cost: + - a bad implementation using linked list where you enqueue at head and dequeue at tail would be O(n) + because you'd need the next to last element, causing a full traversal each dequeue + - enqueue: O(1) (amortized, linked list and array [probing]) + - dequeue: O(1) (linked list and array) + - empty: O(1) (linked list and array) + +- [x] **Hash table** + - [x] https://www.lynda.com/Developer-Programming-Foundations-tutorials/Understanding-hash-functions/149042/177126-4.html + - [x] https://www.lynda.com/Developer-Programming-Foundations-tutorials/Using-hash-tables/149042/177127-4.html + - [x] https://www.lynda.com/Developer-Programming-Foundations-tutorials/Supporting-hashing/149042/177128-4.html + - [x] https://www.lynda.com/Developer-Programming-Foundations-tutorials/Language-support-hash-tables/149042/177129-4.html + - [x] https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/m7UuP/core-hash-tables + - [x] https://www.youtube.com/watch?v=C4Kc8xzcA68 + - [x] https://class.coursera.org/algs4partI-010/lecture/52 + - [x] https://class.coursera.org/algs4partI-010/lecture/53 + - [x] https://class.coursera.org/algs4partI-010/lecture/55 + - [x] https://class.coursera.org/algs4partI-010/lecture/56 + - [x] https://www.coursera.org/learn/data-structures/home/week/3 + - [x] https://www.coursera.org/learn/data-structures/lecture/NYZZP/phone-book-problem + - [x] distributed hash tables: + - https://www.coursera.org/learn/data-structures/lecture/DvaIb/instant-uploads-and-storage-optimization-in-dropbox + - https://www.coursera.org/learn/data-structures/lecture/tvH8H/distributed-hash-tables + - [x] MIT: + - https://www.youtube.com/watch?v=0M_kIqhwbFo&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=8 + - https://www.youtube.com/watch?v=BRO7mVIFt08&index=9&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb + - https://www.youtube.com/watch?v=rvdJDijO2Ro&index=10&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb + - [x] implement with array using linear probing + - hash(k, m) - m is size of hash table + - add(key, value) - if key already exists, update value + - exists(key) + - get(key) + - remove(key) + +## More Knowledge + +- [x] **Binary search:** + - [x] https://www.youtube.com/watch?v=D5SrAga1pno + - [x] https://www.khanacademy.org/computing/computer-science/algorithms/binary-search/a/binary-search + - [x] detail: https://www.topcoder.com/community/data-science/data-science-tutorials/binary-search/ + - [x] Implement: + - binary search (on sorted array of integers) + - binary search using recursion + +- [x] **Bitwise operations** + - [x] Get a really good understanding of manipulating bits with: &, |, ^, ~, >>, << + - [x] words: https://en.wikipedia.org/wiki/Word_(computer_architecture) + - [x] Good intro: + https://www.youtube.com/watch?v=7jkIUgLC29I + - [x] https://www.youtube.com/watch?v=d0AwjSpNXR0 + - [x] https://en.wikipedia.org/wiki/Bit_manipulation + - [x] https://en.wikipedia.org/wiki/Bitwise_operation + - [x] https://graphics.stanford.edu/~seander/bithacks.html + - [x] http://bits.stephan-brumme.com/ + - [x] http://bits.stephan-brumme.com/interactive.html + - [x] 2s and 1s complement + - https://www.youtube.com/watch?v=lKTsv6iVxV4 + - https://en.wikipedia.org/wiki/Ones%27_complement + - https://en.wikipedia.org/wiki/Two%27s_complement + - [x] count set 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 + - [x] round to next power of 2: + - http://bits.stephan-brumme.com/roundUpToNextPowerOfTwo.html + - [x] swap values: + - http://bits.stephan-brumme.com/swap.html + - [x] absolute value: + - http://bits.stephan-brumme.com/absInteger.html + +- [x] **Parity & Hamming Code** + - [x] Parity: + - https://www.youtube.com/watch?v=DdMcAUlxh1M + - [x] Hamming Code: + - Error detection: https://www.youtube.com/watch?v=1A_NcXxdoCc + - Error correction: https://www.youtube.com/watch?v=JAMLuxdHH8o + - [x] Error Checking: + - https://www.youtube.com/watch?v=wbH2VxzmoZk + +## Trees + +- [x] Notes: + - [x] Series: https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/ovovP/core-trees + - [x] Series: https://www.coursera.org/learn/data-structures/lecture/95qda/trees + - basic tree construction + - traversal + - manipulation algorithms + - BFS (breadth-first search) + - MIT: https://www.youtube.com/watch?v=s-CYnVz-uh4&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=13 + - level order (BFS, using queue) + time complexity: O(n) + space complexity: best: O(1), worst: O(n/2)=O(n) + - DFS (depth-first search) + - MIT: https://www.youtube.com/watch?v=AfSk24UTFS8&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=14 + - notes: + time complexity: O(n) + space complexity: + best: O(log n) - avg. height of tree + worst: O(n) + - inorder (DFS: left, self, right) + - postorder (DFS: left, right, self) + - preorder (DFS: self, left, right) + +- [x] **Binary search trees: BSTs** + - [x] Series: https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/p82sw/core-introduction-to-binary-search-trees + - [x] Series: https://class.coursera.org/algs4partI-010/lecture/43 + - starts with symbol table and goes through BST applications + - [x] https://www.coursera.org/learn/data-structures/lecture/E7cXP/introduction + - [x] MIT: https://www.youtube.com/watch?v=9Jry5-82I68 + - C/C++: + - [x] https://www.youtube.com/watch?v=COZK7NATh4k&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=28 + - [x] https://www.youtube.com/watch?v=hWokyBoo0aI&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=29 + - [x] https://www.youtube.com/watch?v=Ut90klNN264&index=30&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P + - [x] https://www.youtube.com/watch?v=_pnqMz5nrRs&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=31 + - [x] https://www.youtube.com/watch?v=9RHO6jU--GU&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=32 + - [x] https://www.youtube.com/watch?v=86g8jAQug04&index=33&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P + - [x] https://www.youtube.com/watch?v=gm8DUJJhmY4&index=34&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P + - [x] https://www.youtube.com/watch?v=yEwSGhSsT0U&index=35&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P + - [x] https://www.youtube.com/watch?v=gcULXE7ViZw&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=36 + - [x] https://www.youtube.com/watch?v=5cPbNCrdotA&index=37&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P + +Know least one type of balanced binary tree (and know how it's implemented): + +- [ ] **AVL trees** + - MIT: https://www.youtube.com/watch?v=FNeL18KsWPc&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=6 + - https://www.coursera.org/learn/data-structures/lecture/Qq5E0/avl-trees + - https://www.coursera.org/learn/data-structures/lecture/PKEBC/avl-tree-implementation + - https://www.coursera.org/learn/data-structures/lecture/22BgE/split-and-merge +- [ ] **red/black tree** + - https://class.coursera.org/algs4partI-010/lecture/50 +- [ ] **splay trees** + - https://www.coursera.org/learn/data-structures/lecture/O9nZ6/splay-trees +- [ ] **B-Trees** + - fun fact: B could stand for Boeing, Balanced, or Bayer (co-inventor) + - https://en.wikipedia.org/wiki/B-tree + - https://class.coursera.org/algs4partI-010/lecture/51 +- [ ] **2-3 (type of B-tree) Search Trees** + - https://class.coursera.org/algs4partI-010/lecture/49 + +- [ ] **N-ary trees** + - 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 + + +## Graphs + +- Notes: + - There are three basic ways to represent a graph in memory: + - objects and pointers + - matrix + - adjacency list + - 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 + - If you get a chance, try to study up on fancier algorithms: + - Dijkstra's algorithm + - https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm + - A* + - https://en.wikipedia.org/wiki/A*_search_algorithm + - When asked a question, look for a graph-based solution first, then move on if none. + +- Compute Strongly Connected Components + - [ ] https://www.coursera.org/learn/algorithms-on-graphs/home/week/5 + +- Implement: + + - [ ] 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 + +- For Curiosity: + - [ ] Radix Sort: https://www.youtube.com/watch?v=xhr26ia4k38 + +## Even 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. + +- [ ] Recursion + - when it is appropriate to use it + +- [ ] open-ended problems + - manipulate strings + - manipulate patterns + +- [ ] Combinatorics (n choose k) + +- [ ] Probability + - https://www.youtube.com/watch?v=sZkAAk9Wwa4 + - https://www.youtube.com/watch?v=dNaJg-mLobQ + +- [ ] Dynamic Programming + +- [ ] Scheduling + +- [ ] Weighted random sampling + +- [ ] Implement system routines + +- [ ] Design patterns: + - description: + - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Foundations-Programming-Design-Patterns/135365-2.html + - Patterns: https://www.youtube.com/playlist?list=PLF206E906175C7E07 + - UML: https://www.youtube.com/playlist?list=PLGLfVvz_LVvQ5G-LdJ8RLqe-ndo7QITYc + - [ ] strategy + - [ ] singleton + - [ ] adapter + - [ ] prototype + - [ ] decorator + - [ ] visitor + - [ ] factory + +- [ ] **Operating Systems (25 videos):** + - https://www.youtube.com/watch?v=-KWd_eQYLwY&index=2&list=PL-XXv-cvA_iBDyz-ba4yDskqMDY6A1w_c + - https://www.quora.com/What-is-the-difference-between-a-process-and-a-thread + Covers: + - Processes, Threads, Concurrency issues + - difference between processes and threads + - processes + - threads + - locks + - mutexes + - semaphores + - monitors + - how they work + - deadlock + - livelock + - CPU activity, interrupts, context switching + - Modern concurrency constructs with multicore processors + - Process resource needs (memory: code, static storage, stack, heap, and also file descriptors, i/o) + - Thread resource needs (shares above with other threads in same process but each has its own pc, stack counter, registers and stack) + - Forking is really copy on write (read-only) until the new process writes to memory, then it does a full copy. + - Context switching + - How context switching is initiated by the operating system and underlying hardware + - [ ] threads in C++: + https://www.youtube.com/playlist?list=PL5jc9xFGsL8E12so1wlMS0r0hTQoJL74M + - 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 + - Transform one data set to another + - Handling obscenely large amounts of data + +- [ ] **System design** + - https://www.quora.com/How-do-I-prepare-to-answer-design-questions-in-a-technical-interview?redirected_qid=1500023 + - features sets + - interfaces + - class hierarchies + - designing a system under certain constraints + - simplicity and robustness + - tradeoffs + - performance analysis and optimization + +- [ ] **Familiarize yourself with a unix-based code editor: emacs & vi(m)** + - suggested by Yegge + - vi(m): + - https://www.youtube.com/watch?v=5givLEMcINQ&index=1&list=PL13bz4SHGmRxlZVmWQ9DvXo1fEg4UdGkr + - set of 4: + - https://www.youtube.com/watch?v=SI8TeVMX8pk + - https://www.youtube.com/watch?v=F3OO7ZIOaJE + - https://www.youtube.com/watch?v=ZYEccA_nMaI + - https://www.youtube.com/watch?v=1lYD5gwgZIA + - emacs: + - https://www.youtube.com/watch?v=hbmV1bnQ-i0 + - set of 3: + - https://www.youtube.com/watch?v=ujODL7MD04Q + - https://www.youtube.com/watch?v=XWpsRupJ4II + - https://www.youtube.com/watch?v=paSgzPso-yc + - https://www.youtube.com/watch?v=JWD1Fpdd4Pc + +- [ ] **Be able to use unix command line tools:** + - suggested by Yegge + - bash + - grep + - sed + - awk + - curl or wget + +- [ ] **Testing** + - how unit testing works + - what are mock onbjects + - what is integration testing + - what is dependency injection + +## Books + +#### Mentioned in Google Coaching: + +- [ ] The Algorithm Design Manual (Skiena) + - 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) + +- [ ] Algorithms and Programming: Problems and Solutions: + http://www.amazon.com/Algorithms-Programming-Solutions-Alexander-Shen/dp/0817638474 + +- [ ] Once you've understood everything in the daily plan: + read and do exercises from the books below. Then move to coding challenges (further down below) + +Read first: +- [ ] Programming Interviews Exposed: Secrets to Landing Your Next Job, 2nd Edition: + http://www.wiley.com/WileyCDA/WileyTitle/productCd-047012167X.html + +Read second: +- [ ] Cracking the Coding Interview, 6th Edition: + - http://www.amazon.com/Cracking-Coding-Interview-6th-Programming/dp/0984782850/ + +#### Additional books (not suggested by Google but I added): + +- [x] C Programming Language, Vol 2 + +- [x] C++ Primer Plus, 6th Edition + +- [ ] Introduction to Algorithms + - https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844 + +- [ ] Programming Pearls: + - http://www.amazon.com/Programming-Pearls-2nd-Jon-Bentley/dp/0201657880 + +If you see people reference "The Google Resume", it was a book replaced by "Cracking the Coding Interview". + +## About Google + +- [ ] How Search Works: + - [ ] https://www.google.com/insidesearch/howsearchworks/thestory/ + - [ ] https://www.youtube.com/watch?v=BNHR6IQJGZs + - [ ] https://www.google.com/insidesearch/howsearchworks/ + +## Articles + +- https://www.topcoder.com/community/data-science/data-science-tutorials/the-importance-of-algorithms/ +- http://highscalability.com/blog/2016/4/4/how-to-remove-duplicates-in-a-large-dataset-reducing-memory.html +- http://highscalability.com/blog/2016/3/23/what-does-etsys-architecture-look-like-today.html +- http://highscalability.com/blog/2016/3/21/to-compress-or-not-to-compress-that-was-ubers-question.html +- http://highscalability.com/blog/2016/3/3/asyncio-tarantool-queue-get-in-the-queue.html +- http://highscalability.com/blog/2016/2/25/when-should-approximate-query-processing-be-used.html +- http://highscalability.com/blog/2016/2/23/googles-transition-from-single-datacenter-to-failover-to-a-n.html +- http://highscalability.com/blog/2016/2/15/egnyte-architecture-lessons-learned-in-building-and-scaling.html +- http://highscalability.com/blog/2016/2/1/a-patreon-architecture-short.html +- http://highscalability.com/blog/2016/1/27/tinder-how-does-one-of-the-largest-recommendation-engines-de.html +- http://highscalability.com/blog/2016/1/25/design-of-a-modern-cache.html +- http://highscalability.com/blog/2016/1/13/live-video-streaming-at-facebook-scale.html +- http://highscalability.com/blog/2016/1/11/a-beginners-guide-to-scaling-to-11-million-users-on-amazons.html +- http://highscalability.com/blog/2015/12/16/how-does-the-use-of-docker-effect-latency.html +- http://highscalability.com/blog/2015/12/14/does-amp-counter-an-existential-threat-to-google.html +- http://highscalability.com/blog/2015/11/9/a-360-degree-view-of-the-entire-netflix-stack.html + +## Papers: + +Computing Weak Consistency in Polynomial Time + - http://dl.acm.org/ft_gateway.cfm?id=2767407&ftid=1607485&dwn=1&CFID=627637486&CFTOKEN=49290244 + +How Developers Search for Code: A Case Study + - http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/43835.pdf + +Borg, Omega, and Kubernetes + - http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/44843.pdf + +Continuous Pipelines at Google + - http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/43790.pdf + +AddressSanitizer: A Fast Address Sanity Checker + - http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/37752.pdf + +## Coding exercises/challenges: + +Once you've learned your brains out, put those brains to work. +Take coding challenges every day, as many as you can. + +- https://courses.csail.mit.edu/iap/interview/materials.php + +The Best: +- LeetCode: https://leetcode.com/ +- Project Euler: https://projecteuler.net/index.php?section=problems +- TopCoder: https://www.topcoder.com/ + +More: +- HackerRank: https://www.hackerrank.com/ +- Codility: https://codility.com/programmers/ +- InterviewCake: https://www.interviewcake.com/ +- InterviewBit: https://www.interviewbit.com/invite/icjf + + +## Once you're closer to the interview: + +- [ ] Cracking The Coding Interview Set 2: + - https://www.youtube.com/watch?v=4NIb9l3imAo + - https://www.youtube.com/watch?v=Eg5-tdAwclo + - https://www.youtube.com/watch?v=1fqxMuPmGak + +## Your Resume + +- http://steve-yegge.blogspot.co.uk/2007_09_01_archive.html + + +## Be thinking of for when the interview comes: + +- Think of about 20 interview questions you'll get, along the lines of the items below: +- have 2-3 answers for each +- Have a story, not just data, about something you accomplished + +- Why do you want this job? +- What's a tough problem you've solved? +- Biggest challenges faced? +- Best/worst designs seen? +- Ideas for improving an existing Google product. +- How do you work best, as an individual and as part of a team? +- Which of your skills or experiences would be assets in the role and why? +- What did you most enjoy at [job x / project y]? +- What was the biggest challenge you faced at [job x / project y]? +- What was the hardest bug you faced at [job x / project y]? +- What did you learn at [job x / project y]? +- What would you have done better at [job x / project y]? + +### Have questions for the interviewer. + +Some of mine (I already may know answer to but want their opinion or team perspective): + +- How large is your team? +- 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 many meetings do you have per week? +- Do you feel your work environment helps you concentrate? +- What are you working on? +- What do you like about it? +- What is the work life like? + +--- + +## Additional Resources + + Everything below is my recommendation, not Google's, and you may not have enough time to + learn, watch or read them all. That's ok. I may not either. + +- [ ] Vector calculus + +- [ ] Computer Security: + - MIT (23 videos): https://www.youtube.com/playlist?list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh + +- [ ] Information theory: + - Markov processes: + - https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/waxgx/core-markov-text-generation + - https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/gZhiC/core-implementing-markov-text-generation + - https://www.khanacademy.org/computing/computer-science/informationtheory/moderninfotheory/v/symbol-rate-information-theory + - includes Markov chain + +- [ ] Bloom Filter + - https://www.youtube.com/watch?v=-SuTGoFYjZs + - http://blog.michaelschmatz.com/2016/04/11/how-to-write-a-bloom-filter-cpp/ + +- [ ] Fast Fourier Transform + - http://jakevdp.github.io/blog/2013/08/28/understanding-the-fft/ + +- [ ] Machine Learning: + - great course: https://www.coursera.org/learn/machine-learning + - http://www.analyticsvidhya.com/blog/2016/04/neural-networks-python-theano/ + - http://www.dataschool.io/ + +- [ ] Parallel Programming: + - https://www.coursera.org/learn/parprog1/home/week/1 + +- [ ] String search algorithms: + 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 + +Sit back and enjoy. "netflix and skill" :P + +- [ ] Scalability: + - https://www.youtube.com/watch?v=9nWyWwY2Onc + - https://www.youtube.com/watch?v=H4vMcD7zKM0 + +- [ ] CSE373 - Analysis of Algorithms (25 videos): + - https://www.youtube.com/watch?v=ZFjhkohHdAA&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b&index=1 + +- [ ] MIT 6.042: Math for CS (25 videos): + - https://www.youtube.com/watch?v=L3LMbpZIKhQ&list=PLB7540DEDD482705B + +- [ ] MIT 6.006: Intro to Algorithms (47 videos): + - https://www.youtube.com/watch?v=HtSuA80QTyo&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&nohtml5=False + +- [ ] MIT 6.033: Computer System Engineering (22 videos): + - https://www.youtube.com/watch?v=zm2VP0kHl1M&list=PL6535748F59DCA484 + +- [ ] MIT 6.046: Design and Analysis of Algorithms (34 videos): + - https://www.youtube.com/watch?v=2P-yW7LQr08&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp + +- [ ] MIT 6.858 Computer Systems Security, Fall 2014 (): + - https://www.youtube.com/watch?v=GqmQg-cszw4&index=1&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh + +- [ ] MIT 6.851: Advanced Data Structures (22 videos): + - https://www.youtube.com/watch?v=T0yzrZL1py0&list=PLUl4u3cNGP61hsJNdULdudlRL493b-XZf&index=1 + +- [ ] Stanford: Programming Paradigms (17 videos) + - https://www.youtube.com/watch?v=jTSvthW34GU&list=PLC0B8B318B7394B6F&nohtml5=False + +- [ ] MIT 6.050J Information and Entropy, Spring 2008 () + - https://www.youtube.com/watch?v=phxsQrZQupo&list=PL_2Bwul6T-A7OldmhGODImZL8KEVE38X7 + +- [ ] Introduction to Cryptography: + - https://www.youtube.com/watch?v=2aHkqB2-46k&feature=youtu.be + +## Maybe + +http://www.gainlo.co/ - Mock interviewers from big companies + +## Code References + +For review questions in C book: + https://github.com/lekkas/c-algorithms + +## Once You've Got The Job + +This is mainly for me. + +- [ ] Books: + - [ ] Clean Code + - [ ] Code Complete + - [ ] How to Prove It: A Structured Approach, 2nd Edition + - [ ] Unix Power Tools, Third Edition + +- [x] C++ Seasoning: + - https://www.youtube.com/watch?v=qH6sSOr-yk8 + +- [x] Better Code: Data Structures: + - https://www.youtube.com/watch?v=sWgDk-o-6ZE + +- [ ] C++ Talks at CPPCon: + - https://www.youtube.com/watch?v=hEx5DNLWGgA&index=2&list=PLHTh1InhhwT75gykhs7pqcR_uSiG601oh + +- [ ] MIT CMS.611J Creating Video Games, Fall 2014 + - https://www.youtube.com/watch?v=pfDfriSjFbY&list=PLUl4u3cNGP61V4W6yRm1Am5zI94m33dXk + +- [ ] Compilers: + - https://class.coursera.org/compilers-004/lecture + +- [ ] Computer and processor architecture: + - https://class.coursera.org/comparch-003/lecture + +- [ ] Long series of C++ videos: + - https://www.youtube.com/playlist?list=PLfVsf4Bjg79Cu5MYkyJ-u4SyQmMhFeC1C + +## Done + +You're never really done. Keep learning. \ No newline at end of file diff --git a/plan.txt b/plan.txt index 3160315..0a21def 100644 --- a/plan.txt +++ b/plan.txt @@ -358,13 +358,13 @@ Notes: - preorder (DFS: self, left, right) -- Binary search trees: BSTs +~~ - Binary search trees: BSTs ~~ * - Series: https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/p82sw/core-introduction-to-binary-search-trees * - Series: https://class.coursera.org/algs4partI-010/lecture/43 - starts with symbol table and goes through BST applications * - https://www.coursera.org/learn/data-structures/lecture/E7cXP/introduction - - MIT: https://www.youtube.com/watch?v=9Jry5-82I68 - - C/C++: + * - MIT: https://www.youtube.com/watch?v=9Jry5-82I68 + ~~ - C/C++: ~~ * - https://www.youtube.com/watch?v=COZK7NATh4k&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=28 * - https://www.youtube.com/watch?v=hWokyBoo0aI&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=29 * - https://www.youtube.com/watch?v=Ut90klNN264&index=30&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P @@ -373,8 +373,8 @@ Notes: * - https://www.youtube.com/watch?v=86g8jAQug04&index=33&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P * - https://www.youtube.com/watch?v=gm8DUJJhmY4&index=34&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P * - https://www.youtube.com/watch?v=yEwSGhSsT0U&index=35&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P - - https://www.youtube.com/watch?v=gcULXE7ViZw&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=36 - - https://www.youtube.com/watch?v=5cPbNCrdotA&index=37&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P + * - https://www.youtube.com/watch?v=gcULXE7ViZw&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=36 + * - https://www.youtube.com/watch?v=5cPbNCrdotA&index=37&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P Know least one type of balanced binary tree (and know how it's implemented): - red/black tree @@ -728,6 +728,10 @@ Additional (not suggested by Google but I added): ## Videos: ########################################################################################## +Scalability: + - https://www.youtube.com/watch?v=9nWyWwY2Onc + - https://www.youtube.com/watch?v=H4vMcD7zKM0 + CSE373 - Analysis of Algorithms (25 videos): - https://www.youtube.com/watch?v=ZFjhkohHdAA&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b&index=1