diff --git a/README.md b/README.md index 25340ac..b5ffc83 100644 --- a/README.md +++ b/README.md @@ -639,7 +639,7 @@ You'll get more graph practice in Skiena's book (see Books section below) and th - [ ] **Testing** - how unit testing works - - what are mock onbjects + - what are mock objects - what is integration testing - what is dependency injection diff --git a/mark.md b/mark.md deleted file mode 100644 index 25340ac..0000000 --- a/mark.md +++ /dev/null @@ -1,920 +0,0 @@ -# Google Interview University -*(formerly known as Project 9894)* - -### 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 - - I have a friendly referral already to get my resume in at Google. Thanks JP. - -## Get in a Googley Mood - -Print out a "[future Googler](https://github.com/jwasham/project-9894/blob/master/future-googler.pdf)" sign (or two) and keep your eyes on the prize. - -## 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 & Background: - - [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 - -- [x] **Balanced binary trees** - - Know least one type of balanced binary tree (and know how it's implemented): - - - [x] **AVL trees** - -[x] MIT: https://www.youtube.com/watch?v=FNeL18KsWPc&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=6 - -[x] https://www.coursera.org/learn/data-structures/lecture/Qq5E0/avl-trees - -[x] https://www.coursera.org/learn/data-structures/lecture/PKEBC/avl-tree-implementation - -[x] https://www.coursera.org/learn/data-structures/lecture/22BgE/split-and-merge - - - [ ] **red/black trees** - - https://class.coursera.org/algs4partI-010/lecture/50 - - - [ ] **splay trees** - - https://www.coursera.org/learn/data-structures/lecture/O9nZ6/splay-trees - - UCB: https://www.youtube.com/watch?v=G5QIXywcJlY - - https://www.youtube.com/watch?v=QnPl_Y6EqMo - - - [ ] **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 search trees** - - 2-3 and B-trees: https://class.coursera.org/algs4partI-010/lecture/49 - - https://www.youtube.com/watch?v=TOb1tuEZ2X4&index=5&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp - -- [ ] **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:** - - UCB: https://www.youtube.com/watch?v=wSPAjGfDl7Q&list=PL4BBB74C7D2A1049C&index=31 - - 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** - - Notes: - - visualized as a tree, but is usually linear in storage (array, linked list) - - https://en.wikipedia.org/wiki/Priority_queue - - https://www.youtube.com/watch?v=yIUFT6AKBGE&index=24&list=PL4BBB74C7D2A1049C - -## Graphs - - This area is sparse (no pun intended), and I'll be filling it in once I get here. - -- 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. - -- Graphs: - - https://www.youtube.com/watch?v=ylWAB6CMYiY&list=PL4BBB74C7D2A1049C&index=27 - -- Weighted graphs: - - https://www.youtube.com/watch?v=zFbq8vOZ_0k&list=PL4BBB74C7D2A1049C&index=28 - -- 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 - - This area is sparse, and I'll be filling it in once I get here. - -- [ ] 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 - - This area is sparse, and I'll be filling it in once I get here. - -- [ ] 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): - - Skiena lectures from Algorithm Design Manual - - https://www.youtube.com/watch?v=ZFjhkohHdAA&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b&index=1 - -- [ ] UC Berkeley 61B - - https://www.youtube.com/playlist?list=PL4BBB74C7D2A1049C - -- [ ] 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) - - Course on C and C++ - - 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 deleted file mode 100644 index 2b3c5e2..0000000 --- a/plan.txt +++ /dev/null @@ -1,7 +0,0 @@ -**************************************** - - - This has moved to README.md - - -**************************************** \ No newline at end of file